deadbyte-mcp 0.11.3 → 0.12.0

package/native/deadbyte-desktop-observer.cpp

@@ -0,0 +1,253 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include <cstdio>
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <sstream>
+#include <iomanip>
+
+struct MonitorRow {
+    RECT rect{};
+    bool primary=false;
+    std::string device;
+};
+
+static std::string Utf8(const wchar_t* value) {
+    if (!value) return {};
+    int needed = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, value, -1, nullptr, 0, nullptr, nullptr);
+    if (needed <= 0) return {};
+    std::string out(static_cast<size_t>(needed), '\0');
+    if (WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, value, -1, out.data(), needed, nullptr, nullptr) <= 0) return {};
+    if (!out.empty() && out.back() == '\0') out.pop_back();
+    return out;
+}
+
+static std::string JsonEscape(const std::string& input) {
+    std::ostringstream out;
+    for (unsigned char ch : input) {
+        switch (ch) {
+            case '"': out << "\\\""; break;
+            case '\\': out << "\\\\"; break;
+            case '\b': out << "\\b"; break;
+            case '\f': out << "\\f"; break;
+            case '\n': out << "\\n"; break;
+            case '\r': out << "\\r"; break;
+            case '\t': out << "\\t"; break;
+            default:
+                if (ch < 0x20) {
+                    out << "\\u" << std::hex << std::setw(4) << std::setfill('0') << static_cast<unsigned int>(ch) << std::dec;
+                } else out << static_cast<char>(ch);
+        }
+    }
+    return out.str();
+}
+
+static BOOL CALLBACK MonitorProc(HMONITOR monitor, HDC, LPRECT, LPARAM param) {
+    auto* rows = reinterpret_cast<std::vector<MonitorRow>*>(param);
+    MONITORINFOEXW info{};
+    info.cbSize = sizeof(info);
+    if (!GetMonitorInfoW(monitor, &info)) return TRUE;
+    MonitorRow row{};
+    row.rect = info.rcMonitor;
+    row.primary = (info.dwFlags & MONITORINFOF_PRIMARY) != 0;
+    row.device = Utf8(info.szDevice);
+    rows->push_back(row);
+    return TRUE;
+}
+
+static bool InputDesktopName(std::string& name) {
+    HDESK desktop = OpenInputDesktop(0, FALSE, DESKTOP_READOBJECTS);
+    if (!desktop) return false;
+    wchar_t buffer[512]{};
+    DWORD needed = 0;
+    BOOL ok = GetUserObjectInformationW(desktop, UOI_NAME, buffer, sizeof(buffer), &needed);
+    CloseDesktop(desktop);
+    if (!ok) return false;
+    name = Utf8(buffer);
+    return true;
+}
+
+static std::string HwndHex(HWND hwnd) {
+    std::ostringstream out;
+    out << "0x" << std::hex << std::nouppercase << reinterpret_cast<uintptr_t>(hwnd);
+    return out.str();
+}
+
+int wmain() {
+    SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+
+    std::string inputDesktop;
+    if (!InputDesktopName(inputDesktop)) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: input desktop unavailable; refusing capture\n");
+        return 10;
+    }
+
+    const int left = GetSystemMetrics(SM_XVIRTUALSCREEN);
+    const int top = GetSystemMetrics(SM_YVIRTUALSCREEN);
+    const int width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+    const int height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+    if (width <= 0 || height <= 0 || width > 32768 || height > 32768) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: virtual desktop bounds invalid\n");
+        return 11;
+    }
+
+    const uint64_t stride = static_cast<uint64_t>(width) * 4u;
+    const uint64_t bytes = stride * static_cast<uint64_t>(height);
+    if (bytes == 0 || bytes > 256ull * 1024ull * 1024ull) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: frame exceeds 256 MiB bound\n");
+        return 12;
+    }
+
+    HDC screen = GetDC(nullptr);
+    if (!screen) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: GetDC failed %lu\n", GetLastError());
+        return 13;
+    }
+    HDC memory = CreateCompatibleDC(screen);
+    if (!memory) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: CreateCompatibleDC failed %lu\n", GetLastError());
+        ReleaseDC(nullptr, screen);
+        return 14;
+    }
+
+    BITMAPINFO bmi{};
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth = width;
+    bmi.bmiHeader.biHeight = -height;
+    bmi.bmiHeader.biPlanes = 1;
+    bmi.bmiHeader.biBitCount = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+
+    void* bits = nullptr;
+    HBITMAP bitmap = CreateDIBSection(screen, &bmi, DIB_RGB_COLORS, &bits, nullptr, 0);
+    if (!bitmap || !bits) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: CreateDIBSection failed %lu\n", GetLastError());
+        if (bitmap) DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 15;
+    }
+    HGDIOBJ old = SelectObject(memory, bitmap);
+    if (!old || old == HGDI_ERROR) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: SelectObject failed %lu\n", GetLastError());
+        DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 16;
+    }
+
+    if (!BitBlt(memory, 0, 0, width, height, screen, left, top, SRCCOPY | CAPTUREBLT)) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: BitBlt failed %lu\n", GetLastError());
+        SelectObject(memory, old);
+        DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 17;
+    }
+    GdiFlush();
+
+    std::vector<MonitorRow> monitors;
+    if (!EnumDisplayMonitors(nullptr, nullptr, MonitorProc, reinterpret_cast<LPARAM>(&monitors)) || monitors.empty()) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: monitor enumeration failed %lu\n", GetLastError());
+        SelectObject(memory, old);
+        DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 18;
+    }
+
+    HWND foreground = GetForegroundWindow();
+    DWORD foregroundPid = 0;
+    std::string foregroundTitle;
+    std::string foregroundImage;
+    if (foreground) {
+        GetWindowThreadProcessId(foreground, &foregroundPid);
+        const int titleLength = GetWindowTextLengthW(foreground);
+        if (titleLength > 0 && titleLength < 32768) {
+            std::vector<wchar_t> title(static_cast<size_t>(titleLength) + 1u, L'\0');
+            const int copied = GetWindowTextW(foreground, title.data(), static_cast<int>(title.size()));
+            if (copied > 0) foregroundTitle = Utf8(title.data());
+        }
+        if (foregroundPid != 0) {
+            HANDLE process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, foregroundPid);
+            if (process) {
+                std::vector<wchar_t> image(32768u, L'\0');
+                DWORD chars = static_cast<DWORD>(image.size());
+                if (QueryFullProcessImageNameW(process, 0, image.data(), &chars) && chars > 0 && chars < image.size()) {
+                    image[chars] = L'\0';
+                    foregroundImage = Utf8(image.data());
+                }
+                CloseHandle(process);
+            }
+        }
+    }
+
+    DWORD sessionId = 0;
+    if (!ProcessIdToSessionId(GetCurrentProcessId(), &sessionId)) sessionId = 0xffffffffu;
+
+    UINT systemDpi = GetDpiForSystem();
+
+    std::ostringstream header;
+    header << "{";
+    header << "\"schema\":\"deadbyte.desktop-native-frame.v1\",";
+    header << "\"backend\":\"gdi-bitblt-fallback\",";
+    header << "\"pixel_format\":\"BGRA8\",";
+    header << "\"left\":" << left << ",";
+    header << "\"top\":" << top << ",";
+    header << "\"width\":" << width << ",";
+    header << "\"height\":" << height << ",";
+    header << "\"stride\":" << stride << ",";
+    header << "\"byte_length\":" << bytes << ",";
+    header << "\"system_dpi\":" << systemDpi << ",";
+    header << "\"session_id\":" << sessionId << ",";
+    header << "\"input_desktop\":\"" << JsonEscape(inputDesktop) << "\",";
+    header << "\"foreground_hwnd\":\"" << HwndHex(foreground) << "\",";
+    header << "\"foreground_pid\":" << foregroundPid << ",";
+    header << "\"foreground_title\":\"" << JsonEscape(foregroundTitle) << "\",";
+    header << "\"foreground_image\":\"" << JsonEscape(foregroundImage) << "\",";
+    header << "\"monitors\":[";
+    for (size_t i = 0; i < monitors.size(); ++i) {
+        if (i) header << ",";
+        const auto& m = monitors[i];
+        header << "{";
+        header << "\"left\":" << m.rect.left << ",";
+        header << "\"top\":" << m.rect.top << ",";
+        header << "\"width\":" << (m.rect.right - m.rect.left) << ",";
+        header << "\"height\":" << (m.rect.bottom - m.rect.top) << ",";
+        header << "\"primary\":" << (m.primary ? "true" : "false") << ",";
+        header << "\"device\":\"" << JsonEscape(m.device) << "\"";
+        header << "}";
+    }
+    header << "]}";
+
+    if (_setmode(_fileno(stdout), _O_BINARY) == -1) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: stdout binary mode failed\n");
+        SelectObject(memory, old);
+        DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 19;
+    }
+
+    const std::string headerText = header.str();
+    if (std::fwrite(headerText.data(), 1, headerText.size(), stdout) != headerText.size() ||
+        std::fwrite("\n", 1, 1, stdout) != 1 ||
+        std::fwrite(bits, 1, static_cast<size_t>(bytes), stdout) != static_cast<size_t>(bytes) ||
+        std::fflush(stdout) != 0) {
+        std::fprintf(stderr, "deadbyte-desktop-observer: stdout write failed\n");
+        SelectObject(memory, old);
+        DeleteObject(bitmap);
+        DeleteDC(memory);
+        ReleaseDC(nullptr, screen);
+        return 20;
+    }
+
+    SelectObject(memory, old);
+    DeleteObject(bitmap);
+    DeleteDC(memory);
+    ReleaseDC(nullptr, screen);
+    return 0;
+}

package/native/deadbyte-desktop-uia.cpp

@@ -0,0 +1,307 @@
+#include <windows.h>
+#include <UIAutomation.h>
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <cerrno>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cwctype>
+#include <oleauto.h>
+
+static constexpr size_t kMaxRequest = 8192;
+static constexpr int kMaxVisited = 2048;
+static constexpr int kMaxResultsHard = 16;
+
+struct Match {
+    LONG left{};
+    LONG top{};
+    LONG width{};
+    LONG height{};
+    int controlType{};
+    bool enabled{};
+    bool offscreen{};
+};
+
+struct Request {
+    HWND expectedHwnd{};
+    DWORD expectedPid{};
+    std::string kind;
+    int maxResults{8};
+    std::string queryUtf8;
+};
+
+static void fail(const char* message, int code = 2) {
+    std::fprintf(stderr, "deadbyte-desktop-uia: %s\n", message);
+    std::exit(code);
+}
+
+static bool parseUnsigned(const std::string& text, unsigned long long& out, int base = 10) {
+    if (text.empty()) return false;
+    char* end = nullptr;
+    errno = 0;
+    const auto v = std::strtoull(text.c_str(), &end, base);
+    if (errno != 0 || end == text.c_str() || *end != '\0') return false;
+    out = v;
+    return true;
+}
+
+static std::vector<std::string> readHeaderLines(const std::string& bytes, size_t count, size_t& offset) {
+    std::vector<std::string> lines;
+    offset = 0;
+    for (size_t i = 0; i < count; ++i) {
+        const auto pos = bytes.find('\n', offset);
+        if (pos == std::string::npos) fail("request header truncated");
+        std::string line = bytes.substr(offset, pos - offset);
+        if (!line.empty() && line.back() == '\r') line.pop_back();
+        lines.push_back(line);
+        offset = pos + 1;
+    }
+    return lines;
+}
+
+static std::string field(const std::string& line, const char* key) {
+    const std::string prefix = std::string(key) + "=";
+    if (line.rfind(prefix, 0) != 0) fail("request field order/name invalid");
+    return line.substr(prefix.size());
+}
+
+static Request readRequest() {
+    std::string bytes;
+    bytes.resize(kMaxRequest + 1);
+    const size_t got = std::fread(bytes.data(), 1, bytes.size(), stdin);
+    if (std::ferror(stdin)) fail("stdin read failed");
+    if (got > kMaxRequest) fail("request exceeds bound");
+    bytes.resize(got);
+
+    size_t offset = 0;
+    const auto lines = readHeaderLines(bytes, 6, offset);
+    if (lines[0] != "DEADBYTE_DESKTOP_UIA_V1") fail("request magic invalid");
+
+    Request r;
+    const auto hwndText = field(lines[1], "expected_hwnd");
+    const auto pidText = field(lines[2], "expected_pid");
+    r.kind = field(lines[3], "query_kind");
+    const auto maxText = field(lines[4], "max_results");
+    const auto queryBytesText = field(lines[5], "query_bytes");
+
+    unsigned long long hwndValue = 0, pidValue = 0, maxValue = 0, queryBytes = 0;
+    std::string h = hwndText;
+    if (h.rfind("0x", 0) == 0 || h.rfind("0X", 0) == 0) h = h.substr(2);
+    if (!parseUnsigned(h, hwndValue, 16) || hwndValue == 0) fail("expected_hwnd invalid");
+    if (!parseUnsigned(pidText, pidValue) || pidValue == 0 || pidValue > 0x7fffffffULL) fail("expected_pid invalid");
+    if (!parseUnsigned(maxText, maxValue) || maxValue < 1 || maxValue > kMaxResultsHard) fail("max_results invalid");
+    if (!parseUnsigned(queryBytesText, queryBytes) || queryBytes > 512) fail("query_bytes invalid");
+    if (offset + queryBytes != bytes.size()) fail("query payload length mismatch");
+
+    r.expectedHwnd = reinterpret_cast<HWND>(static_cast<uintptr_t>(hwndValue));
+    r.expectedPid = static_cast<DWORD>(pidValue);
+    r.maxResults = static_cast<int>(maxValue);
+    r.queryUtf8.assign(bytes.data() + offset, static_cast<size_t>(queryBytes));
+
+    const bool needsQuery = r.kind != "root";
+    if (needsQuery && r.queryUtf8.empty()) fail("query required");
+    if (!needsQuery && !r.queryUtf8.empty()) fail("root query must be empty");
+    if (r.kind != "root" && r.kind != "name_exact" && r.kind != "name_contains" &&
+        r.kind != "automation_id_exact" && r.kind != "control_type") fail("query_kind invalid");
+    return r;
+}
+
+static std::wstring utf8ToWide(const std::string& input) {
+    if (input.empty()) return {};
+    const int n = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), nullptr, 0);
+    if (n <= 0) fail("query UTF-8 invalid");
+    std::wstring out(static_cast<size_t>(n), L'\0');
+    if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), out.data(), n) != n) fail("query UTF-8 conversion failed");
+    return out;
+}
+
+static std::wstring lower(std::wstring s) {
+    std::transform(s.begin(), s.end(), s.begin(), [](wchar_t c) { return static_cast<wchar_t>(std::towlower(c)); });
+    return s;
+}
+
+static int controlTypeFromQuery(const std::string& q) {
+    struct Pair { const char* name; int id; };
+    static const Pair map[] = {
+        {"button", UIA_ButtonControlTypeId}, {"checkbox", UIA_CheckBoxControlTypeId},
+        {"combobox", UIA_ComboBoxControlTypeId}, {"edit", UIA_EditControlTypeId},
+        {"hyperlink", UIA_HyperlinkControlTypeId}, {"list", UIA_ListControlTypeId},
+        {"listitem", UIA_ListItemControlTypeId}, {"menu", UIA_MenuControlTypeId},
+        {"menuitem", UIA_MenuItemControlTypeId}, {"radio", UIA_RadioButtonControlTypeId},
+        {"tab", UIA_TabControlTypeId}, {"tabitem", UIA_TabItemControlTypeId},
+        {"text", UIA_TextControlTypeId}, {"toolbar", UIA_ToolBarControlTypeId},
+        {"tree", UIA_TreeControlTypeId}, {"treeitem", UIA_TreeItemControlTypeId},
+        {"document", UIA_DocumentControlTypeId}, {"window", UIA_WindowControlTypeId},
+        {"pane", UIA_PaneControlTypeId}, {"group", UIA_GroupControlTypeId}
+    };
+    for (const auto& item : map) if (q == item.name) return item.id;
+    return 0;
+}
+
+static bool matches(IUIAutomationElement* e, const Request& r, const std::wstring& queryWide, int queryControlType) {
+    if (r.kind == "root") return true;
+    if (r.kind == "control_type") {
+        CONTROLTYPEID type = 0;
+        return SUCCEEDED(e->get_CurrentControlType(&type)) && type == queryControlType;
+    }
+
+    BSTR raw = nullptr;
+    HRESULT hr = E_FAIL;
+    if (r.kind == "automation_id_exact") hr = e->get_CurrentAutomationId(&raw);
+    else hr = e->get_CurrentName(&raw);
+    if (FAILED(hr) || raw == nullptr) {
+        if (raw) SysFreeString(raw);
+        return false;
+    }
+    std::wstring value(raw, SysStringLen(raw));
+    SysFreeString(raw);
+    value = lower(std::move(value));
+    const auto query = lower(queryWide);
+    if (r.kind == "name_contains") return value.find(query) != std::wstring::npos;
+    return value == query;
+}
+
+static bool captureMatch(IUIAutomationElement* e, Match& out) {
+    RECT rc{};
+    if (FAILED(e->get_CurrentBoundingRectangle(&rc))) return false;
+    if (rc.right <= rc.left || rc.bottom <= rc.top) return false;
+    BOOL offscreen = TRUE, enabled = FALSE;
+    e->get_CurrentIsOffscreen(&offscreen);
+    e->get_CurrentIsEnabled(&enabled);
+    if (offscreen) return false;
+    CONTROLTYPEID type = 0;
+    e->get_CurrentControlType(&type);
+    out.left = rc.left; out.top = rc.top;
+    out.width = rc.right - rc.left; out.height = rc.bottom - rc.top;
+    out.controlType = type; out.enabled = enabled != FALSE; out.offscreen = offscreen != FALSE;
+    return true;
+}
+
+static void walk(IUIAutomationTreeWalker* walker, IUIAutomationElement* parent, const Request& req,
+    const std::wstring& queryWide, int queryControlType, int depth, int& visited,
+    bool& truncated, std::vector<Match>& matchesOut) {
+    if (depth > 64 || visited >= kMaxVisited || static_cast<int>(matchesOut.size()) >= req.maxResults) return;
+    IUIAutomationElement* child = nullptr;
+    if (FAILED(walker->GetFirstChildElement(parent, &child)) || child == nullptr) return;
+    while (child != nullptr) {
+        ++visited;
+        if (visited >= kMaxVisited) truncated = true;
+        if (matches(child, req, queryWide, queryControlType)) {
+            Match m;
+            if (captureMatch(child, m)) matchesOut.push_back(m);
+        }
+        if (!truncated && static_cast<int>(matchesOut.size()) < req.maxResults) {
+            walk(walker, child, req, queryWide, queryControlType, depth + 1, visited, truncated, matchesOut);
+        }
+        IUIAutomationElement* next = nullptr;
+        walker->GetNextSiblingElement(child, &next);
+        child->Release();
+        child = next;
+        if (truncated || static_cast<int>(matchesOut.size()) >= req.maxResults) {
+            if (child) child->Release();
+            break;
+        }
+    }
+}
+
+static unsigned long long hwndNumber(HWND h) {
+    return static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(h));
+}
+
+static int runSelftest() {
+    if (controlTypeFromQuery("button") != UIA_ButtonControlTypeId) return 2;
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-selftest.v1\",\"status\":\"passed\"}\n");
+    return 0;
+}
+
+int wmain(int argc, wchar_t** argv) {
+    if (argc == 2 && std::wstring(argv[1]) == L"--selftest") return runSelftest();
+    const Request req = readRequest();
+
+    HWND fg = GetForegroundWindow();
+    DWORD pid = 0;
+    if (fg) GetWindowThreadProcessId(fg, &pid);
+    if (fg != req.expectedHwnd || pid != req.expectedPid) fail("foreground window identity changed", 3);
+
+    const HRESULT init = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    if (FAILED(init) && init != RPC_E_CHANGED_MODE) fail("CoInitializeEx failed", 4);
+    const bool uninit = SUCCEEDED(init);
+
+    IUIAutomation* automation = nullptr;
+    HRESULT hr = CoCreateInstance(CLSID_CUIAutomation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&automation));
+    if (FAILED(hr) || !automation) {
+        if (uninit) CoUninitialize();
+        fail("CUIAutomation creation failed", 5);
+    }
+
+    IUIAutomationElement* root = nullptr;
+    hr = automation->ElementFromHandle(fg, &root);
+    if (FAILED(hr) || !root) {
+        automation->Release(); if (uninit) CoUninitialize();
+        fail("ElementFromHandle failed", 6);
+    }
+
+    std::vector<Match> found;
+    int visited = 0;
+    bool truncated = false;
+    const std::wstring queryWide = utf8ToWide(req.queryUtf8);
+    const int queryControlType = req.kind == "control_type" ? controlTypeFromQuery(req.queryUtf8) : 0;
+    if (req.kind == "control_type" && queryControlType == 0) {
+        root->Release(); automation->Release(); if (uninit) CoUninitialize();
+        fail("unsupported control_type query", 7);
+    }
+
+    if (req.kind == "root") {
+        ++visited;
+        RECT wr{};
+        if (GetWindowRect(fg, &wr)) {
+            const LONG vx = GetSystemMetrics(SM_XVIRTUALSCREEN);
+            const LONG vy = GetSystemMetrics(SM_YVIRTUALSCREEN);
+            const LONG vr = vx + GetSystemMetrics(SM_CXVIRTUALSCREEN);
+            const LONG vb = vy + GetSystemMetrics(SM_CYVIRTUALSCREEN);
+            const LONG left = (std::max)(wr.left, vx);
+            const LONG top = (std::max)(wr.top, vy);
+            const LONG right = (std::min)(wr.right, vr);
+            const LONG bottom = (std::min)(wr.bottom, vb);
+            if (right > left && bottom > top && IsWindowVisible(fg)) {
+                Match m;
+                m.left = left; m.top = top; m.width = right - left; m.height = bottom - top;
+                m.controlType = UIA_WindowControlTypeId;
+                m.enabled = IsWindowEnabled(fg) != FALSE;
+                m.offscreen = false;
+                found.push_back(m);
+            }
+        }
+    } else {
+        IUIAutomationTreeWalker* walker = nullptr;
+        hr = automation->get_ControlViewWalker(&walker);
+        if (FAILED(hr) || !walker) {
+            root->Release(); automation->Release(); if (uninit) CoUninitialize();
+            fail("ControlViewWalker unavailable", 8);
+        }
+        walk(walker, root, req, queryWide, queryControlType, 0, visited, truncated, found);
+        walker->Release();
+    }
+
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-ground.v1\",\"foreground_hwnd\":\"0x%llx\",\"foreground_pid\":%lu,"
+                "\"query_kind\":\"%s\",\"visited\":%d,\"truncated\":%s,\"matches\":[",
+        hwndNumber(fg), static_cast<unsigned long>(pid), req.kind.c_str(), visited, truncated ? "true" : "false");
+    for (size_t i = 0; i < found.size(); ++i) {
+        if (i) std::printf(",");
+        const auto& m = found[i];
+        std::printf("{\"left\":%ld,\"top\":%ld,\"width\":%ld,\"height\":%ld,\"control_type\":%d,"
+                    "\"enabled\":%s,\"offscreen\":%s}",
+            m.left, m.top, m.width, m.height, m.controlType,
+            m.enabled ? "true" : "false", m.offscreen ? "true" : "false");
+    }
+    std::printf("]}\n");
+
+    root->Release();
+    automation->Release();
+    if (uninit) CoUninitialize();
+    return 0;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "private": false,
   "type": "module",
-  "description": "Authenticated MCP machine-truth runtime with signed audit chain, immutable release slots, contained execution, coding/autonomous production authority, and npx-first remote control.",
+  "description": "Authenticated MCP machine-truth runtime with signed audit chain, immutable release slots, contained execution, coding/autonomous production authority, guarded Windows Desktop computer-use, and npx-first remote control.",
   "engines": {
     "node": ">=22"
   },
@@ -12,10 +12,10 @@
     "manifest:write": "node scripts/release-manifest.mjs write",
     "manifest:verify": "node scripts/release-manifest.mjs verify",
     "self-update:runtime": "node scripts/runtime-self-update.mjs",
-    "self-update:deferred": "node scripts/deferred-slot-operation-r39.mjs",
-    "release:parity": "node scripts/release-parity-r39.mjs",
-    "release:final:write": "node scripts/final-closure-r39.mjs",
-    "release:final:verify": "node scripts/final-closure-verify-r39.mjs",
+    "self-update:deferred": "node scripts/deferred-slot-operation-r40.mjs",
+    "release:parity": "node scripts/release-parity-r40.mjs",
+    "release:final:write": "node scripts/final-closure-r40.mjs",
+    "release:final:verify": "node scripts/final-closure-verify-r40.mjs",
     "proof": "node src/proof-cli.mjs workspaces/demo input.txt",
     "verify": "node src/verifier-cli.mjs workspaces/demo evidence/latest.json",
     "trust:init": "node src/trust-init.mjs",
@@ -38,7 +38,7 @@
     "contained:run": "node src/contained-cli.mjs workspaces/demo input.txt",
     "contained:smoke": "node src/contained-smoke.mjs",
     "mcp:contained:smoke": "node src/mcp-contained-smoke-client.mjs",
-    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r39.ps1",
+    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r40.ps1",
     "authority:smoke": "node src/authority-smoke.mjs",
     "mcp:remote:smoke": "node src/remote-mcp-smoke-client.mjs",
     "mcp:host:smoke": "node src/mcp-host-smoke-client.mjs",
@@ -47,7 +47,9 @@
     "mcp:remote:autonomous:smoke": "node src/remote-mcp-autonomous-smoke-client.mjs",
     "mcp:tunnel-compat:smoke": "node src/tunnel-stdio-compat-smoke.mjs",
     "audit:verify": "node src/deadbyte-cli.mjs audit verify",
-    "audit:status": "node src/deadbyte-cli.mjs audit status"
+    "audit:status": "node src/deadbyte-cli.mjs audit status",
+    "desktop:build": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/build-desktop-r40.ps1",
+    "desktop:policy:refresh": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/init-desktop-policy-r40.ps1"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",