Skip to content

Xbox Cloud Gaming app for PS5 Homebrew

C
27.4 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
#include "app/web_server.h"
#include "app/report.h"
#include "app/settings.h"
#include "input/key_map.h"
#include "input/pad_map.h"
#include "platform/platform.h"
#include "ui/app_ui.h"
#include "util/json.h"
#include "util/log.h"

#include <algorithm>
#include <arpa/inet.h>
#include <cerrno>
#include <csignal>
#include <cstring>
#include <fcntl.h>
#include <mbedtls/base64.h>
#include <mbedtls/sha1.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <poll.h>
#include <sys/socket.h>
#include <thread>
#include <unistd.h>

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

namespace xc::app {

static WebServerHooks s_hooks;

namespace {

std::string extractJsonField(const std::string& body, const std::string& field) {
    auto j = json::parse(body);
    if (j && j->isObject()) {
        auto val = (*j)[field];
        if (val.isString()) return val.str();
    }
    // Fallback: simple urlencoded or key=value
    std::string needle = field + "=";
    auto pos = body.find(needle);
    if (pos != std::string::npos) {
        auto end = body.find('&', pos);
        if (end == std::string::npos) end = body.size();
        return body.substr(pos + needle.size(), end - (pos + needle.size()));
    }
    return "";
}

}  // namespace

std::unique_ptr<WebServer> g_webServer;

WebServer::WebServer() = default;

WebServer::~WebServer() {
    stop();
}

std::string WebServer::localIp() const {
    return platform::localIPv4();
}

std::string WebServer::url() const {
    return "http://" + localIp() + ":" + std::to_string(port_);
}

bool WebServer::start(uint16_t port) {
#ifdef SIGPIPE
    ::signal(SIGPIPE, SIG_IGN);
#endif
    if (running_.load()) return true;
    port_ = port;

    listenFd_ = ::socket(AF_INET, SOCK_STREAM, 0);
    if (listenFd_ < 0) {
        XC_LOGW("web server: socket() failed (errno %d)", errno);
        return false;
    }

    int one = 1;
    ::setsockopt(listenFd_, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port_);

    if (::bind(listenFd_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
        XC_LOGW("web server: bind(%u) failed (errno %d)", port_, errno);
        ::close(listenFd_);
        listenFd_ = -1;
        return false;
    }

    if (::listen(listenFd_, 8) < 0) {
        XC_LOGW("web server: listen() failed (errno %d)", errno);
        ::close(listenFd_);
        listenFd_ = -1;
        return false;
    }

    running_.store(true);
    if (!platform::startThread(thread_, [this] { threadLoop(); })) {
        XC_LOGW("web server: failed to start thread");
        running_.store(false);
        ::close(listenFd_);
        listenFd_ = -1;
        return false;
    }

    XC_LOGI("web server: running at %s", url().c_str());
    return true;
}

void WebServer::stop() {
    if (!running_.exchange(false)) return;
    if (listenFd_ >= 0) {
        ::shutdown(listenFd_, SHUT_RDWR);
        ::close(listenFd_);
        listenFd_ = -1;
    }
    {
        std::lock_guard<std::mutex> lock(wsMutex_);
        for (int fd : wsClients_) {
            ::shutdown(fd, SHUT_RDWR);
        }
        wsClients_.clear();
    }
    if (thread_.joinable()) {
        thread_.join();
    }
    XC_LOGI("web server: stopped");
}

void WebServer::threadLoop() {
    platform::setThreadAffinity(platform::ThreadRole::Worker, "xcloud_web");
    while (running_.load()) {
        pollfd pfd{listenFd_, POLLIN, 0};
        int pr = ::poll(&pfd, 1, 250);
        if (pr <= 0) continue;
        if (pfd.revents & POLLIN) {
            sockaddr_in clientAddr{};
            socklen_t clientLen = sizeof(clientAddr);
            int clientFd = ::accept(listenFd_, reinterpret_cast<sockaddr*>(&clientAddr), &clientLen);
            if (clientFd >= 0) {
                std::thread([this, clientFd]() {
                    handleClient(clientFd);
                    ::close(clientFd);
                }).detach();
            }
        }
    }
}

void WebServer::handleClient(int clientFd) {
    timeval tv{2, 0};  // 2s timeout prevents hung clients from deadlocking server thread
    ::setsockopt(clientFd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    ::setsockopt(clientFd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
#ifdef SO_NOSIGPIPE
    int nosig = 1;
    ::setsockopt(clientFd, SOL_SOCKET, SO_NOSIGPIPE, &nosig, sizeof(nosig));
#endif

    std::string req;
    char buf[8192];
    size_t contentLength = 0;
    bool headersComplete = false;

    while (req.size() < 65536) {
        ssize_t n = ::recv(clientFd, buf, sizeof(buf), 0);
        if (n <= 0) break;
        req.append(buf, static_cast<size_t>(n));

        if (!headersComplete) {
            auto hdrEnd = req.find("\r\n\r\n");
            if (hdrEnd != std::string::npos) {
                headersComplete = true;
                std::string lowerHdr = req.substr(0, hdrEnd);
                for (char& c : lowerHdr) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
                auto clPos = lowerHdr.find("content-length:");
                if (clPos != std::string::npos) {
                    size_t valStart = clPos + 15;
                    while (valStart < hdrEnd && (lowerHdr[valStart] == ' ' || lowerHdr[valStart] == '\t')) valStart++;
                    size_t valEnd = lowerHdr.find("\r\n", valStart);
                    if (valEnd != std::string::npos) {
                        try {
                            contentLength = std::stoul(lowerHdr.substr(valStart, valEnd - valStart));
                        } catch (...) {}
                    }
                }
            }
        }

        if (headersComplete) {
            auto hdrEnd = req.find("\r\n\r\n");
            size_t bodyReceived = req.size() - (hdrEnd + 4);
            if (bodyReceived >= contentLength) {
                break;
            }
        }
    }

    if (req.empty()) return;

    auto lineEnd = req.find("\r\n");
    if (lineEnd == std::string::npos) lineEnd = req.find('\n');
    if (lineEnd == std::string::npos) return;

    std::string firstLine = req.substr(0, lineEnd);
    auto sp1 = firstLine.find(' ');
    auto sp2 = firstLine.rfind(' ');
    if (sp1 == std::string::npos || sp2 == std::string::npos || sp1 >= sp2) return;

    std::string method = firstLine.substr(0, sp1);
    std::string path = firstLine.substr(sp1 + 1, sp2 - (sp1 + 1));

    // Strip query string if any from path
    auto qpos = path.find('?');
    if (qpos != std::string::npos) path = path.substr(0, qpos);

    // WebSocket upgrade check
    auto hdrEnd = req.find("\r\n\r\n");
    if (hdrEnd != std::string::npos) {
        std::string lowerHdr = req.substr(0, hdrEnd);
        for (char& c : lowerHdr) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
        bool isWs = (lowerHdr.find("upgrade: websocket") != std::string::npos ||
                     (lowerHdr.find("upgrade:") != std::string::npos && lowerHdr.find("websocket") != std::string::npos));
        if (isWs && (path == "/ws" || path == "/api/ws")) {
            auto keyPos = lowerHdr.find("sec-websocket-key:");
            if (keyPos != std::string::npos) {
                size_t valStart = keyPos + 18;
                while (valStart < hdrEnd && (req[valStart] == ' ' || req[valStart] == '\t')) valStart++;
                size_t valEnd = req.find("\r\n", valStart);
                if (valEnd != std::string::npos) {
                    std::string secKey = req.substr(valStart, valEnd - valStart);
                    std::string accept = ws::computeAccept(secKey);
                    std::string resp = "HTTP/1.1 101 Switching Protocols\r\n"
                                       "Upgrade: websocket\r\n"
                                       "Connection: Upgrade\r\n"
                                       "Sec-WebSocket-Accept: " + accept + "\r\n\r\n";
                    ::send(clientFd, resp.data(), resp.size(), MSG_NOSIGNAL);
                    handleWebSocket(clientFd);
                    return;
                }
            }
        }
    }

    // Find body if present
    std::string body;
    if (hdrEnd != std::string::npos) {
        body = req.substr(hdrEnd + 4);
        if (contentLength > 0 && body.size() > contentLength) {
            body.resize(contentLength);
        }
    }

    HttpResponse res = handleRequest(method, path, body);

    std::string statusText = res.status == 200   ? "200 OK"
                             : res.status == 204 ? "204 No Content"
                             : res.status == 400 ? "400 Bad Request"
                             : res.status == 404 ? "404 Not Found"
                                                 : "500 Internal Server Error";

    std::string response = "HTTP/1.1 " + statusText + "\r\n";
    response += "Content-Type: " + res.contentType + "\r\n";
    response += "Content-Length: " + std::to_string(res.body.size()) + "\r\n";
    response += "Access-Control-Allow-Origin: *\r\n";
    response += "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n";
    response += "Access-Control-Allow-Headers: Content-Type\r\n";
    if (!res.extraHeaders.empty()) response += res.extraHeaders;
    response += "Connection: close\r\n\r\n";
    if (method != "HEAD") {
        response += res.body;
    }

    size_t sent = 0;
    while (sent < response.size()) {
        ssize_t w = ::send(clientFd, response.data() + sent, response.size() - sent, MSG_NOSIGNAL);
        if (w <= 0) break;
        sent += static_cast<size_t>(w);
    }
}

void WebServer::handleWebSocket(int wsFd) {
    int nodelay = 1;
    ::setsockopt(wsFd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));

    {
        std::lock_guard<std::mutex> lock(wsMutex_);
        wsClients_.push_back(wsFd);
    }

    std::vector<uint8_t> inBuf;
    uint8_t recvBuf[4096];
    uint64_t lastTelMs = 0;

    while (running_.load()) {
        pollfd pfd{wsFd, POLLIN, 0};
        int pr = ::poll(&pfd, 1, 30);  // ~33 Hz tick
        if (pr < 0) {
            if (errno == EINTR) continue;
            break;
        }
        if (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
            break;
        }
        if (pfd.revents & POLLIN) {
            ssize_t n = ::recv(wsFd, recvBuf, sizeof(recvBuf), 0);
            if (n <= 0) break;
            if (inBuf.size() + n > 65536) inBuf.clear();
            inBuf.insert(inBuf.end(), recvBuf, recvBuf + n);

            ws::Frame frame;
            size_t consumed = 0;
            while (ws::parseFrame(inBuf.data(), inBuf.size(), frame, consumed)) {
                inBuf.erase(inBuf.begin(), inBuf.begin() + consumed);
                if (frame.opcode == ws::Opcode::Close) {
                    auto closeResp = ws::makeCloseFrame();
                    ::send(wsFd, closeResp.data(), closeResp.size(), MSG_NOSIGNAL);
                    goto done;
                } else if (frame.opcode == ws::Opcode::Ping) {
                    auto pong = ws::makePongFrame(frame.payload);
                    ::send(wsFd, pong.data(), pong.size(), MSG_NOSIGNAL);
                } else if (frame.opcode == ws::Opcode::Text) {
                    std::string jsonStr(reinterpret_cast<const char*>(frame.payload.data()), frame.payload.size());
                    auto j = json::parse(jsonStr);
                    if (j && j->isObject()) {
                        int slot = 0;
                        input::ControllerState s{};
                        if (parseGamepadJson(*j, slot, s)) {
                            if ((*j).has("activeSwitch") && (*j)["activeSwitch"].asBool()) {
                                switchVirtualGamepadSlot(slot);
                            }
                            setVirtualGamepad(slot, s);
                            if (s_hooks.injectGamepad) s_hooks.injectGamepad(slot, s);
                        }
                    }
                } else if (frame.opcode == ws::Opcode::Binary) {
                    if (frame.payload.size() >= 13) {
                        int slot = frame.payload[0] & 0x03;
                        uint16_t btns = static_cast<uint16_t>(frame.payload[1]) | (static_cast<uint16_t>(frame.payload[2]) << 8);
                        input::ControllerState s{};
                        s.connected = true;
                        s.btnA = (btns & 0x0001) != 0;
                        s.btnB = (btns & 0x0002) != 0;
                        s.btnX = (btns & 0x0004) != 0;
                        s.btnY = (btns & 0x0008) != 0;
                        s.dpadUp = (btns & 0x0010) != 0;
                        s.dpadDown = (btns & 0x0020) != 0;
                        s.dpadLeft = (btns & 0x0040) != 0;
                        s.dpadRight = (btns & 0x0080) != 0;
                        s.btnL1 = (btns & 0x0100) != 0;
                        s.btnR1 = (btns & 0x0200) != 0;
                        s.btnL3 = (btns & 0x0400) != 0;
                        s.btnR3 = (btns & 0x0800) != 0;
                        s.btnTouchpad = (btns & 0x1000) != 0;
                        s.btnOptions = (btns & 0x2000) != 0;
                        s.btnNexus = (btns & 0x4000) != 0;
                        s.triggerL2 = static_cast<float>(frame.payload[3]) / 255.0f;
                        s.triggerR2 = static_cast<float>(frame.payload[4]) / 255.0f;
                        int16_t lx = static_cast<int16_t>(frame.payload[5] | (frame.payload[6] << 8));
                        int16_t ly = static_cast<int16_t>(frame.payload[7] | (frame.payload[8] << 8));
                        int16_t rx = static_cast<int16_t>(frame.payload[9] | (frame.payload[10] << 8));
                        int16_t ry = static_cast<int16_t>(frame.payload[11] | (frame.payload[12] << 8));
                        s.leftStickX = std::clamp(static_cast<float>(lx) / 32768.0f, -1.0f, 1.0f);
                        s.leftStickY = std::clamp(static_cast<float>(ly) / 32768.0f, -1.0f, 1.0f);
                        s.rightStickX = std::clamp(static_cast<float>(rx) / 32768.0f, -1.0f, 1.0f);
                        s.rightStickY = std::clamp(static_cast<float>(ry) / 32768.0f, -1.0f, 1.0f);
                        s.rawLeftX = s.leftStickX;
                        s.rawLeftY = s.leftStickY;
                        s.rawRightX = s.rightStickX;
                        s.rawRightY = s.rightStickY;
                        setVirtualGamepad(slot, s);
                        if (s_hooks.injectGamepad) s_hooks.injectGamepad(slot, s);
                    }
                }
            }
        }

        uint64_t now = platform::nowMs();
        if (now - lastTelMs >= 30) {  // ~33 fps telemetry
            lastTelMs = now;
            json::Value tel = json::Value::object();
            tel.set("type", "telemetry");
            json::Value stats = json::Value::object();
            if (s_hooks.getTelemetry) s_hooks.getTelemetry(stats);
            tel.set("stats", stats);
            auto f = ws::makeTextFrame(tel.dump());
            ssize_t sent = ::send(wsFd, f.data(), f.size(), MSG_NOSIGNAL);
            if (sent < 0 && (errno != EAGAIN && errno != EWOULDBLOCK)) {
                break;
            }
        }
    }

done:
    {
        std::lock_guard<std::mutex> lock(wsMutex_);
        auto it = std::find(wsClients_.begin(), wsClients_.end(), wsFd);
        if (it != wsClients_.end()) wsClients_.erase(it);
    }
}

void setWebServerHooks(WebServerHooks hooks) {
    s_hooks = std::move(hooks);
}

WebServer::HttpResponse WebServer::handleRequest(const std::string& method, const std::string& path,
                                                 const std::string& body) {
    if (method == "OPTIONS") {
        return {204, "text/plain", "", ""};
    }

    if (method == "GET" || method == "HEAD") {
        if (path == "/" || path == "/index.html" || path == "/boost" || path == "/boost/" || path == "/gamepad" || path == "/gamepad/") {
            return {200, "text/html; charset=utf-8", "", webServerIndexHtml()};
        }
        if (path == "/api/settings" || path == "/api/status" || path == "/api/state") {
            json::Value root = json::Value::object();
            root.set("ok", true);
            bool streaming = s_hooks.isStreaming ? s_hooks.isStreaming() : false;
            root.set("streaming", streaming);
            if (s_hooks.getSettings) {
                s_hooks.getSettings(root);
            } else {
                root.set("language", "en");
                root.set("resolution", "1080p");
                root.set("padMap", input::padMapJson(input::defaultPadMap()));
                root.set("keyMap", keyMapToJson(input::defaultKeyMap()));
                root.set("touchpadShortcuts", input::touchpadShortcutsJson(input::defaultTouchpadShortcuts()));
            }
            if (s_hooks.getSearchParams) {
                std::string q, tab;
                json::Value filters = json::Value::object();
                s_hooks.getSearchParams(q, tab, filters);
                root.set("query", q);
                root.set("tab", tab);
                root.set("filters", filters);
            } else if (s_hooks.getSearchQuery) {
                root.set("query", s_hooks.getSearchQuery());
                root.set("tab", "gamepass");
                root.set("filters", json::Value::object());
            } else {
                root.set("query", "");
                root.set("tab", "gamepass");
                root.set("filters", json::Value::object());
            }
            return {200, "application/json", "", root.dump()};
        }
        if (path == "/api/log" || path == "/api/log/prev") {
            bool prev = (path == "/api/log/prev");
            std::string filename = prev ? "xcloud.prev.log" : "xcloud.log";
            std::string rawLog;
            platform::readFile(platform::dataDir() + "/" + filename, rawLog);
            if (rawLog.empty() && prev) {
                platform::readFile(platform::dataDir() + "/xcloud.log", rawLog);
            }
            std::string clean = report::sanitize(rawLog, {});
            return {200, "text/plain; charset=utf-8", "Content-Disposition: attachment; filename=\"" + filename + "\"\r\n", clean};
        }
        if (path == "/api/report-issue" || path.rfind("/api/report-issue?", 0) == 0) {
            std::string rawLog;
            platform::readFile(platform::dataDir() + "/xcloud.log", rawLog);
            std::vector<std::string> privWords;
            for (int i = 0; i < input::kMaxPads; ++i) {
                std::string u = input::padUserName(i);
                if (!u.empty()) privWords.push_back(std::move(u));
            }

            report::Info info;
            info.title = "Relatório via WebUI";
            info.what = "Enviado através do painel WebUI do PSBox";
            info.release = XC_APP_VERSION;
            info.firmware = platform::firmwareVersion();
            info.platform = platform::platformName();
            std::string platHeader = "[Platform: " + info.platform + "]\n";
            info.log = platHeader + report::sanitize(report::logExcerpt(rawLog, false), privWords);
            std::string url = report::issueUrl(info);

            json::Value resp = json::Value::object();
            resp.set("ok", true);
            resp.set("url", url);
            resp.set("title", info.title);
            resp.set("platform", info.platform);
            resp.set("release", info.release);
            resp.set("firmware", info.firmware);
            resp.set("excerpt", info.log);
            return {200, "application/json; charset=utf-8", "", resp.dump()};
        }
        if (path == "/api/stats") {
            json::Value stats = json::Value::object();
            if (s_hooks.getTelemetry) {
                s_hooks.getTelemetry(stats);
            }
            return {200, "application/json", "", stats.dump()};
        }
        if (path == "/api/stream") {
            json::Value menu = json::Value::object();
            if (s_hooks.getStreamMenuState) {
                s_hooks.getStreamMenuState(menu);
            }
            return {200, "application/json", "", menu.dump()};
        }
        if (path == "/ws" || path == "/api/ws") {
            return {101, "application/json", "", "{\"ok\":true,\"endpoint\":\"websocket\"}"};
        }
    }

    if (method == "POST") {
        if (path == "/api/report-issue") {
            std::string title = "Relatório via WebUI";
            std::string what = "Enviado através do painel WebUI do PSBox";
            auto j = json::parse(body);
            if (j && j->isObject()) {
                if ((*j).has("title") && (*j)["title"].isString() && !(*j)["title"].asString().empty()) {
                    title = (*j)["title"].asString();
                }
                if ((*j).has("what") && (*j)["what"].isString() && !(*j)["what"].asString().empty()) {
                    what = (*j)["what"].asString();
                }
            }
            std::string rawLog;
            platform::readFile(platform::dataDir() + "/xcloud.log", rawLog);

            std::vector<std::string> privWords;
            for (int i = 0; i < input::kMaxPads; ++i) {
                std::string u = input::padUserName(i);
                if (!u.empty()) privWords.push_back(std::move(u));
            }

            report::Info info;
            info.title = report::shorten(title, 70);
            info.what = report::sanitize(what, privWords);
            info.release = XC_APP_VERSION;
            info.firmware = platform::firmwareVersion();
            info.platform = platform::platformName();
            std::string platHeader = "[Platform: " + info.platform + "]\n";
            info.log = platHeader + report::sanitize(report::logExcerpt(rawLog, false), privWords);
            std::string url = report::issueUrl(info);

            json::Value resp = json::Value::object();
            resp.set("ok", true);
            resp.set("url", url);
            resp.set("title", info.title);
            resp.set("platform", info.platform);
            resp.set("release", info.release);
            resp.set("firmware", info.firmware);
            resp.set("excerpt", info.log);
            return {200, "application/json; charset=utf-8", "", resp.dump()};
        }
        if (path == "/api/gamepad" || path == "/api/input") {
            auto j = json::parse(body);
            if (!j || !j->isObject()) {
                return {400, "application/json", "", "{\"ok\":false,\"error\":\"invalid json\"}"};
            }
            int slot = 0;
            input::ControllerState s{};
            if (!parseGamepadJson(*j, slot, s)) {
                return {400, "application/json", "", "{\"ok\":false,\"error\":\"invalid state\"}"};
            }

            if ((*j).has("activeSwitch") && (*j)["activeSwitch"].asBool()) {
                switchVirtualGamepadSlot(slot);
            }
            setVirtualGamepad(slot, s);
            if (s_hooks.injectGamepad) {
                s_hooks.injectGamepad(slot, s);
            }

            json::Value res = json::Value::object();
            res.set("ok", true);
            res.set("player", slot + 1);
            return {200, "application/json", "", res.dump()};
        }
        if (path == "/api/search") {
            bool streaming = s_hooks.isStreaming ? s_hooks.isStreaming() : false;
            if (streaming) {
                json::Value res = json::Value::object();
                res.set("ok", false);
                res.set("error", "streaming_active");
                res.set("message", "Desativado enquanto jogando");
                return {409, "application/json", "", res.dump()};
            }
            auto j = json::parse(body);
            std::string q;
            std::string tab = "gamepass";
            json::Value filtersObj = json::Value::object();
            bool hasQuery = false;
            bool hasTab = false;
            bool hasFilters = false;

            if (j && j->isObject()) {
                if ((*j).has("query") && (*j)["query"].isString()) {
                    q = (*j)["query"].str();
                    hasQuery = true;
                }
                if ((*j).has("tab") && (*j)["tab"].isString()) {
                    tab = (*j)["tab"].str();
                    hasTab = true;
                }
                if ((*j).has("filters") && (*j)["filters"].isObject()) {
                    filtersObj = (*j)["filters"];
                    hasFilters = true;
                }
                for (const char* k : {"wishlist", "free", "cheapest", "mouseKeyboard", "plan", "console", "mode", "language",
                                      "filterWishlist", "filterFree", "filterCheapest", "filterMouseKeyboard", "filterPlan", "filterConsole",
                                      "filterMode", "filterLanguage"}) {
                    if ((*j).has(k)) {
                        filtersObj.set(k, (*j)[k]);
                        hasFilters = true;
                    }
                }
            } else {
                q = extractJsonField(body, "query");
                hasQuery = !q.empty() || body.find("query=") != std::string::npos;
                std::string t = extractJsonField(body, "tab");
                if (!t.empty()) {
                    tab = t;
                    hasTab = true;
                }
            }

            if (s_hooks.setSearchParams) {
                s_hooks.setSearchParams(hasQuery ? &q : nullptr, hasTab ? &tab : nullptr, hasFilters ? &filtersObj : nullptr);
            } else if (s_hooks.setSearchQuery && hasQuery) {
                s_hooks.setSearchQuery(q);
            }

            if (!hasTab && s_hooks.getSearchParams) {
                std::string curQ, curTab;
                json::Value curF = json::Value::object();
                s_hooks.getSearchParams(curQ, curTab, curF);
                if (!curTab.empty()) tab = curTab;
            }

            json::Value res = json::Value::object();
            res.set("ok", true);
            res.set("query", q);
            res.set("tab", tab);
            res.set("filters", filtersObj);
            return {200, "application/json", "", res.dump()};
        }
        if (path == "/api/settings") {
            auto j = json::parse(body);
            if (!j || !j->isObject()) {
                return {400, "application/json", "", "{\"ok\":false,\"error\":\"invalid json\"}"};
            }
            bool ok = true;
            if (s_hooks.updateSettings) {
                ok = s_hooks.updateSettings(*j);
            }
            return {ok ? 200 : 400, "application/json", "", ok ? "{\"ok\":true}" : "{\"ok\":false,\"error\":\"update failed\"}"};
        }
        if (path == "/api/stream") {
            auto j = json::parse(body);
            if (!j || !j->isObject()) {
                return {400, "application/json", "", "{\"ok\":false,\"error\":\"invalid json\"}"};
            }
            if ((*j).has("action") && (*j)["action"].isString()) {
                std::string act = (*j)["action"].str();
                if (s_hooks.streamAction) {
                    s_hooks.streamAction(act);
                }
            }
            bool ok = true;
            if (s_hooks.updateStreamMenu) {
                ok = s_hooks.updateStreamMenu(*j);
            }
            json::Value res = json::Value::object();
            res.set("ok", ok);
            return {ok ? 200 : 400, "application/json", "", res.dump()};
        }
    }

    return {404, "text/plain", "", "404 Not Found\n"};
}

void startWebServer(uint16_t port) {
    if (!g_webServer) {
        g_webServer = std::make_unique<WebServer>();
    }
    g_webServer->start(port);
}

void stopWebServer() {
    if (g_webServer) {
        g_webServer->stop();
    }
}

std::string webServerUrl() {
    return g_webServer ? g_webServer->url() : "http://" + platform::localIPv4() + ":8080";
}

}  // namespace xc::app