@weavetab/mcp 2.5.0-beta.0

package/dist/tools/github/read.js

@@ -0,0 +1,74 @@
+import { getRepoContext, isGithubError } from "./repoContext.js";
+import { loadRepoCache } from "./cache.js";
+import { githubAnalyze } from "./analyze.js";
+export async function githubRead(session, args, config) {
+    const context = await getRepoContext(session, args.repo);
+    if (isGithubError(context))
+        return context;
+    const { owner, repo } = context;
+    // Check cache to get default_branch and file_tree
+    let cached = await loadRepoCache(owner, repo, config);
+    if (!cached) {
+        // We need cache to get default_branch. Call analyze first.
+        const analyzeResult = await githubAnalyze(session, config, args.repo);
+        if (isGithubError(analyzeResult)) {
+            return analyzeResult;
+        }
+        cached = analyzeResult;
+    }
+    const default_branch = cached.default_branch;
+    const file_tree = cached.file_tree;
+    const results = [];
+    const warnings = [];
+    const fetchPromises = args.paths.map(async (rawPath) => {
+        // Sanitize path
+        const path = rawPath.replace(/\\/g, '/').replace(/^\/+/, '');
+        if (path.includes('..') || path.includes('\0')) {
+            return { path: rawPath, error: "INVALID_PATH", message: "Path traversal or null bytes detected." };
+        }
+        // Check if path exists in tree
+        const exists = file_tree.some(entry => entry.path === path);
+        if (!exists) {
+            warnings.push(`Path '${path}' was not found in the cached file tree. Branch contents may differ.`);
+        }
+        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${default_branch}/${path}`;
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const res = await fetch(rawUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!res.ok) {
+                return { path, error: "FETCH_FAILED", status: res.status, message: res.statusText };
+            }
+            const content = await res.text();
+            const lines = content.split('\n');
+            const total_lines = lines.length;
+            let returnedContent = content;
+            let truncated = false;
+            if (args.line_range && Array.isArray(args.line_range) && args.line_range.length === 2) {
+                const start = Math.max(0, args.line_range[0] - 1); // 1-indexed to 0-indexed
+                const end = Math.min(total_lines, args.line_range[1]);
+                returnedContent = lines.slice(start, end).join('\n');
+                truncated = (start > 0 || end < total_lines);
+            }
+            else if (total_lines > 200) {
+                returnedContent = lines.slice(0, 200).join('\n');
+                truncated = true;
+            }
+            return {
+                path,
+                total_lines,
+                truncated,
+                content: returnedContent
+            };
+        }
+        catch (err) {
+            return { path, error: "FETCH_ERROR", message: err.message };
+        }
+    });
+    const pathResults = await Promise.all(fetchPromises);
+    return {
+        warnings: warnings.length > 0 ? warnings : undefined,
+        files: pathResults
+    };
+}

package/dist/tools/github/repoContext.d.ts

@@ -0,0 +1,20 @@
+import CDP from "chrome-remote-interface";
+export interface RepoContext {
+    owner: string;
+    repo: string;
+}
+export type GithubToolError = {
+    error: string;
+    message: string;
+    [key: string]: any;
+};
+/**
+ * Resolve the current GitHub repo context.
+ *
+ * @param session  - CDP session
+ * @param repoSlug - Optional "owner/repo" or full GitHub URL. When provided,
+ *                   the function uses it directly instead of reading the tab URL.
+ *                   If the browser is not already on GitHub it navigates there.
+ */
+export declare function getRepoContext(session: CDP.Client, repoSlug?: unknown): Promise<RepoContext | GithubToolError>;
+export declare function isGithubError(result: any): result is GithubToolError;

package/dist/tools/github/repoContext.js

@@ -0,0 +1,129 @@
+/**
+ * Parse a repo slug from a string that can be:
+ *  - "owner/repo"
+ *  - "https://github.com/owner/repo[/anything]"
+ *
+ * Returns null (instead of throwing) for any non-string input so callers
+ * never encounter `TypeError: slug.trim is not a function`.
+ */
+function parseRepoSlug(slug) {
+    // ── Enterprise guard: reject any non-string at runtime ─────────────────────
+    // Zod marks `repo` as optional(string), but MCP argument dispatch can
+    // forward an object / number / null when the model omits the field in some
+    // call patterns.  Checking typeof here is the only safe boundary.
+    if (typeof slug !== "string")
+        return null;
+    const trimmed = slug.trim();
+    if (!trimmed)
+        return null;
+    // Full GitHub URL
+    try {
+        const u = new URL(trimmed);
+        if (u.hostname === "github.com") {
+            const parts = u.pathname.split("/").filter(Boolean);
+            if (parts.length >= 2)
+                return { owner: parts[0], repo: parts[1] };
+        }
+    }
+    catch { /* not a URL — fall through to shorthand parse */ }
+    // "owner/repo" shorthand
+    const parts = trimmed.split("/").filter(Boolean);
+    if (parts.length >= 2)
+        return { owner: parts[0], repo: parts[1] };
+    return null;
+}
+/**
+ * Resolve the current GitHub repo context.
+ *
+ * @param session  - CDP session
+ * @param repoSlug - Optional "owner/repo" or full GitHub URL. When provided,
+ *                   the function uses it directly instead of reading the tab URL.
+ *                   If the browser is not already on GitHub it navigates there.
+ */
+export async function getRepoContext(session, repoSlug) {
+    // ── Runtime type normalisation ────────────────────────────────────────────
+    // `repoSlug` is declared optional(string) in the Zod schema, but callers
+    // such as server.ts cast `(args as any).repo`, meaning any JS value can
+    // arrive here.  Normalise to string | undefined before any string ops.
+    const slugStr = typeof repoSlug === "string" && repoSlug.trim() !== ""
+        ? repoSlug.trim()
+        : undefined;
+    // If a repo slug was explicitly given, prefer it over the current tab URL.
+    if (slugStr) {
+        const parsed = parseRepoSlug(slugStr);
+        if (!parsed) {
+            return {
+                error: "INVALID_REPO_SLUG",
+                message: `Cannot parse a GitHub owner/repo from "${slugStr}". Use "owner/repo" or a full github.com URL.`
+            };
+        }
+        // Check whether the browser is already on a matching GitHub page.
+        // If not, navigate there so downstream tools that read the DOM work correctly.
+        try {
+            const { result } = await session.Runtime.evaluate({
+                expression: 'window.location.href',
+                returnByValue: true,
+            });
+            const currentUrl = (typeof result.value === "string" ? result.value : "");
+            const isOnMatchingRepo = currentUrl.includes(`github.com/${parsed.owner}/${parsed.repo}`);
+            if (!isOnMatchingRepo) {
+                const targetUrl = `https://github.com/${parsed.owner}/${parsed.repo}`;
+                await session.Page.navigate({ url: targetUrl });
+                // Wait briefly for the page to start loading
+                await new Promise(r => setTimeout(r, 1500));
+            }
+        }
+        catch { /* non-fatal — proceed with parsed slug */ }
+        return parsed;
+    }
+    // No slug given: read from current tab URL (original behaviour)
+    let urlStr;
+    try {
+        const { result } = await session.Runtime.evaluate({
+            expression: 'window.location.href',
+            returnByValue: true,
+        });
+        urlStr = result.value;
+    }
+    catch (err) {
+        return {
+            error: "CONTEXT_ERROR",
+            message: "Failed to evaluate window.location.href on the active tab."
+        };
+    }
+    if (!urlStr) {
+        return {
+            error: "CONTEXT_ERROR",
+            message: "Active tab URL is empty."
+        };
+    }
+    let url;
+    try {
+        url = new URL(urlStr);
+    }
+    catch {
+        return {
+            error: "INVALID_URL",
+            message: "Active tab URL is invalid."
+        };
+    }
+    if (url.hostname !== "github.com") {
+        return {
+            error: "NOT_ON_GITHUB_REPO",
+            message: "Navigate to a GitHub repository first, or pass a 'repo' argument (e.g. \"owner/repo\")."
+        };
+    }
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts.length < 2) {
+        return {
+            error: "NOT_ON_GITHUB_REPO",
+            message: "Navigate to a specific GitHub repository first (e.g. github.com/owner/repo)."
+        };
+    }
+    const owner = parts[0];
+    const repo = parts[1];
+    return { owner, repo };
+}
+export function isGithubError(result) {
+    return result && typeof result === "object" && "error" in result && "message" in result;
+}

package/dist/tools/highlight.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Weavetab — tools/highlight.ts
+ * browser_highlight: draws a CSS shimmer animation over the element that auto-fades.
+ * Falls back through 5 strategies so w:NN refs always resolve.
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface HighlightOptions {
+    selector?: string;
+    id?: string;
+    ref?: string;
+    target?: string;
+    label?: string;
+    nodeId?: number;
+    color?: string;
+}
+export declare function browserHighlight(session: CDP.Client, options: HighlightOptions, _config: Config): Promise<{
+    success: boolean;
+    message: string;
+}>;

package/dist/tools/highlight.js

@@ -0,0 +1,140 @@
+import { getConfigAgentId } from "../config/loader.js";
+export async function browserHighlight(session, options, _config) {
+    const { selector, nodeId } = options;
+    // Inject shimmer keyframe once
+    await session.Runtime.evaluate({
+        expression: `(function(){
+      if (!document.getElementById('wt-shimmer-style')) {
+        var s = document.createElement('style');
+        s.id = 'wt-shimmer-style';
+        s.textContent = '@keyframes wt-shimmer{0%{opacity:0;background-position:-200% 0}15%{opacity:0.9}40%{opacity:0.7}85%{opacity:0.3}100%{opacity:0;background-position:200% 0}}';
+        (document.head || document.documentElement).appendChild(s);
+      }
+    })()`,
+        returnByValue: true,
+    }).catch(() => { });
+    // Draw shimmer overlay at raw coordinates — works without any DOM query
+    function makeCoordShimmer(x, y, w, h) {
+        return `(function(){
+      var div = document.createElement('div');
+      div.style.cssText = 'position:fixed;left:${x}px;top:${y}px;width:${w}px;height:${h}px;z-index:2147483647;pointer-events:none;background:linear-gradient(120deg,transparent 30%,rgba(139,92,246,0.3) 50%,transparent 70%);background-size:200% 100%;animation:wt-shimmer 0.5s ease-out forwards;border:1.5px solid rgba(139,92,246,0.6);border-radius:3px;box-shadow:0 0 8px rgba(139,92,246,0.25);';
+      (document.getElementById('Weavetab-root')?.shadowRoot || document.getElementById('Weavetab-root') || document.body).appendChild(div);
+      setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 600);
+      return true;
+    })()`;
+    }
+    // Draw shimmer by querying a CSS selector
+    function makeSelectorShimmer(sel) {
+        const escaped = sel.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        return `(function(){
+      var el;
+      try { el = document.querySelector('${escaped}'); } catch(e) {}
+      if (!el && window.__Weavetab_shadowQuery) {
+        try { el = window.__Weavetab_shadowQuery('${escaped}'); } catch(e) {}
+      }
+      if (!el) return false;
+      var r = el.getBoundingClientRect();
+      if (r.width === 0 && r.height === 0) return false;
+      var div = document.createElement('div');
+      div.style.cssText = 'position:fixed;left:'+r.left+'px;top:'+r.top+'px;width:'+r.width+'px;height:'+r.height+'px;z-index:2147483647;pointer-events:none;background:linear-gradient(120deg,transparent 30%,rgba(139,92,246,0.3) 50%,transparent 70%);background-size:200% 100%;animation:wt-shimmer 0.5s ease-out forwards;border:1.5px solid rgba(139,92,246,0.6);border-radius:3px;box-shadow:0 0 8px rgba(139,92,246,0.25);';
+      (document.getElementById('Weavetab-root')?.shadowRoot || document.getElementById('Weavetab-root') || document.body).appendChild(div);
+      setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 600);
+      return true;
+    })()`;
+    }
+    async function trySelector(sel) {
+        const r = await session.Runtime.evaluate({ expression: makeSelectorShimmer(sel), returnByValue: true })
+            .catch(() => ({ result: { value: false } }));
+        return !!r?.result?.value;
+    }
+    // Use CDP DOM.getBoxModel to get coordinates for a backendNodeId — no DOM query needed
+    async function tryNodeHighlight(bnId) {
+        try {
+            const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [bnId] });
+            if (!nodeIds?.[0])
+                return false;
+            const box = await session.DOM.getBoxModel({ nodeId: nodeIds[0] }).catch(() => null);
+            if (!box?.model?.content)
+                return false;
+            const q = box.model.content;
+            const x = q[0], y = q[1], w = q[2] - q[0], h = q[5] - q[1];
+            if (w <= 0 || h <= 0)
+                return false;
+            const r = await session.Runtime.evaluate({ expression: makeCoordShimmer(x, y, w, h), returnByValue: true });
+            return !!r?.result?.value;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Resolve params ─────────────────────────────────────────────────────────
+    let resolvedSelector = selector;
+    let numericId = null;
+    if (!resolvedSelector) {
+        const refId = options.id || options.ref || options.target;
+        if (refId) {
+            const stripped = refId.replace(/^w:/, '');
+            numericId = parseInt(stripped, 10);
+            resolvedSelector = `[data-wt-id="${stripped}"]`;
+        }
+        else if (options.label) {
+            resolvedSelector = `[aria-label="${options.label.replace(/"/g, '\\"')}"]`;
+        }
+    }
+    // Strategy 1: CSS selector query
+    if (resolvedSelector && await trySelector(resolvedSelector)) {
+        return { success: true, message: `Highlighted ${resolvedSelector}` };
+    }
+    // Strategy 2: Extension oracle coords (__Weavetab_getCoords)
+    if (resolvedSelector) {
+        const coordsRes = await session.Runtime.evaluate({
+            expression: `(window.__Weavetab_getCoords || window.__Weavetab_getCoords || function(){return null;})(${JSON.stringify(resolvedSelector)})`,
+            returnByValue: true,
+        }).catch(() => null);
+        const cv = coordsRes?.result?.value;
+        if (cv?.raw) {
+            const { left, top, w, h } = cv.raw;
+            const r = await session.Runtime.evaluate({ expression: makeCoordShimmer(left, top, w, h), returnByValue: true });
+            if (r?.result?.value)
+                return { success: true, message: `Highlighted ${resolvedSelector} via coords` };
+        }
+    }
+    // Strategy 3: CDP DOM by backendNodeId (for explicit nodeId param)
+    if (nodeId && await tryNodeHighlight(nodeId)) {
+        return { success: true, message: `Highlighted backendNodeId ${nodeId}` };
+    }
+    // Strategy 4: Walk action map cache to find the backendNodeId for a w:NN ref
+    if (numericId !== null) {
+        try {
+            const { getCachedActionMap } = await import('../state/cache.js');
+            const { sessionRegistry } = await import('../state/session.js');
+            const activeClient = sessionRegistry.getActive(getConfigAgentId(_config));
+            const targetId = activeClient?.targetId || 'default';
+            const cachedMap = activeClient?.url ? getCachedActionMap(targetId, activeClient.url) : null;
+            if (cachedMap?.elements) {
+                const el = cachedMap.elements.find(e => {
+                    const n = parseInt(String(e.id).replace(/^w:/, ''), 10);
+                    return n === numericId;
+                });
+                if (el?.selector && await trySelector(el.selector)) {
+                    return { success: true, message: `Highlighted w:${numericId} via cache selector` };
+                }
+                if (el?.backendNodeId && await tryNodeHighlight(el.backendNodeId)) {
+                    return { success: true, message: `Highlighted w:${numericId} via action map backendNodeId` };
+                }
+                // Strategy 5: coordinate fallback from cached element position
+                if (el?.x !== undefined && el?.y !== undefined) {
+                    const ew = el.width ?? 80, eh = el.height ?? 24;
+                    const r = await session.Runtime.evaluate({
+                        expression: makeCoordShimmer(el.x - ew / 2, el.y - eh / 2, ew, eh),
+                        returnByValue: true,
+                    });
+                    if (r?.result?.value)
+                        return { success: true, message: `Highlighted w:${numericId} via cache coords` };
+                }
+            }
+        }
+        catch { /* no cache */ }
+    }
+    return { success: false, message: `Could not find element to highlight` };
+}

package/dist/tools/hover.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Weavetab — tools/hover.ts
+ * browser_hover: dispatch mouseMoveTo CDP event on a nodeId or selector.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface HoverOptions {
+    selector?: string;
+    nodeId?: number;
+    waitForChild?: string;
+    holdMs?: number;
+}
+export declare function browserHover(session: CDP.Client, options: HoverOptions, config: Config): Promise<{
+    success: boolean;
+    x: number;
+    y: number;
+}>;
+//# sourceMappingURL=hover.d.ts.map

package/dist/tools/hover.js

@@ -0,0 +1,57 @@
+export async function browserHover(session, options, config) {
+    const { selector, nodeId, waitForChild, holdMs = 300 } = options;
+    let x, y;
+    if (selector) {
+        const res = await session.Runtime.evaluate({
+            expression: `window.__Weavetab_getCoords(${JSON.stringify(selector)})`,
+            returnByValue: true
+        }).catch(() => null);
+        const coords = res?.result?.value;
+        if (!coords)
+            throw new Error(`Selector not found or unresolved: ${selector}`);
+        x = coords.x;
+        y = coords.y;
+    }
+    else if (nodeId) {
+        try {
+            const { model } = await session.DOM.getBoxModel({ backendNodeId: nodeId });
+            x = (model.content[0] + model.content[2]) / 2;
+            y = (model.content[1] + model.content[5]) / 2;
+        }
+        catch {
+            throw new Error(`Failed to get box model for nodeId ${nodeId}`);
+        }
+    }
+    else {
+        throw new Error("browser_hover requires either selector or nodeId");
+    }
+    // Move mouse to element via CDP
+    await session.Input.dispatchMouseEvent({
+        type: "mouseMoved",
+        x,
+        y
+    });
+    // Dispatch both mouseenter AND mouseover (some sites only listen to one)
+    await session.Runtime.evaluate({
+        expression: `(function(sel) {
+      const el = document.querySelector(sel) || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(sel) : null);
+      if (!el) return;
+      el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: false, cancelable: true }));
+      el.dispatchEvent(new MouseEvent('mouseover',  { bubbles: true,  cancelable: true }));
+    })(${JSON.stringify(selector || '')})`,
+        returnByValue: true
+    }).catch(() => { });
+    await new Promise(r => setTimeout(r, holdMs));
+    // If waiting for submenu, use browserWait
+    if (waitForChild) {
+        const { browserWait } = await import("./wait.js");
+        await browserWait(session, {
+            for: "element",
+            value: waitForChild,
+            timeout: 5000
+        }, config);
+        await new Promise(r => setTimeout(r, 200)); // let animation finish
+    }
+    return { success: true, x, y };
+}
+//# sourceMappingURL=hover.js.map

package/dist/tools/inspect.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Weavetab — tools/inspect.ts
+ * browser_inspect: Return detailed CSS styles, computed styles, and event listeners for an element.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface InspectOptions {
+    nodeId?: number;
+    selector?: string;
+    ref?: string;
+}
+export declare function browserInspect(session: CDP.Client, options: InspectOptions, _config: Config): Promise<{
+    success: boolean;
+    data: any;
+    message: string;
+}>;

package/dist/tools/inspect.js

@@ -0,0 +1,125 @@
+import { getConfigAgentId } from "../config/loader.js";
+import { getCachedActionMap, cacheActionMap } from "../state/cache.js";
+import { sessionRegistry } from "../state/session.js";
+import { buildActionMap } from "../cdp/walker.js";
+export async function browserInspect(session, options, _config) {
+    let { nodeId, selector, ref } = options;
+    if (!nodeId && !selector && !ref) {
+        throw new Error("browser_inspect requires nodeId, selector, or ref");
+    }
+    const { DOM, CSS, DOMDebugger } = session;
+    await DOM.enable();
+    const doc = await DOM.getDocument({ depth: -1 }).catch(() => null);
+    await CSS.enable().catch(() => { });
+    let resolvedNodeId = nodeId || null;
+    // Step 1: Resolve a live nodeId from any input
+    if (!resolvedNodeId && ref) {
+        const active = sessionRegistry.getActive(getConfigAgentId(_config));
+        if (active) {
+            // getCachedActionMap returns null when the DOM has mutated since the last
+            // read (lastMutationTime > lastReadTime). On a cache miss, rebuild the map
+            // so ref IDs remain resolvable after any DOM change instead of silently
+            // falling through to "Could not resolve element to a node ID".
+            let map = getCachedActionMap(active.targetId);
+            if (!map) {
+                try {
+                    map = await buildActionMap(session, { lite: true }, active.targetId);
+                    cacheActionMap(active.targetId, map);
+                }
+                catch { /* best-effort; will fall through to selector strategies */ }
+            }
+            if (map) {
+                const el = map.elements.find((e) => e.id === ref || e.id.endsWith(ref.startsWith("w:") ? ref.slice(2) : ref));
+                if (el?.backendNodeId) {
+                    const desc = await DOM.describeNode({ backendNodeId: el.backendNodeId }).catch(() => null);
+                    if (desc?.node?.nodeId)
+                        resolvedNodeId = desc.node.nodeId;
+                }
+                if (!resolvedNodeId && el?.selector) {
+                    selector = el.selector;
+                }
+                // Also try data-wt-id selector directly when backendNodeId lookup fails
+                if (!resolvedNodeId && ref) {
+                    const rawId = ref.startsWith("w:") ? ref.slice(2) : ref;
+                    selector = selector || `[data-wt-id="${rawId}"]`;
+                }
+            }
+        }
+    }
+    if (!resolvedNodeId && selector) {
+        const res = await session.Runtime.evaluate({
+            expression: `(function(sel) {
+        var els = document.querySelectorAll(sel);
+        for (var i = 0; i < els.length; i++) {
+          if (!els[i].closest('#wt-shadow-host, [data-wt-ignore]')) {
+            return els[i];
+          }
+        }
+        return els[0] || null;
+      })(${JSON.stringify(selector)})`,
+        });
+        if (res.result?.objectId) {
+            const nodeRes = await DOM.requestNode({ objectId: res.result.objectId }).catch(() => null);
+            if (nodeRes?.nodeId)
+                resolvedNodeId = nodeRes.nodeId;
+        }
+    }
+    if (!resolvedNodeId) {
+        throw new Error("Could not resolve element to a node ID");
+    }
+    // Step 2: Fetch box model, computed styles, and event listeners in parallel
+    const boxModel = await DOM.getBoxModel({ nodeId: resolvedNodeId }).catch(() => null);
+    // Try CSS.getComputedStyleForNode first (CDP-native), fall back to Runtime.evaluate
+    let computedStylesData = null;
+    const cssResult = await CSS.getComputedStyleForNode({ nodeId: resolvedNodeId }).catch(() => null);
+    if (cssResult?.computedStyle) {
+        const INTERESTING = ['display', 'position', 'width', 'height', 'margin', 'padding', 'color', 'background-color', 'font-size', 'visibility', 'opacity', 'z-index', 'pointer-events'];
+        computedStylesData = cssResult.computedStyle
+            .filter((s) => INTERESTING.includes(s.name))
+            .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.value }), {});
+    }
+    if (!computedStylesData && selector) {
+        // Fallback: use window.getComputedStyle via Runtime.evaluate
+        const { result: fallbackRes } = await session.Runtime.evaluate({
+            expression: `(function(sel) {
+        var el = document.querySelector(sel);
+        if (!el) return null;
+        var s = window.getComputedStyle(el);
+        var KEYS = ['display','position','width','height','margin','padding','color','background-color','font-size','visibility','opacity','z-index','pointer-events'];
+        var r = {};
+        for (var i = 0; i < KEYS.length; i++) r[KEYS[i]] = s.getPropertyValue(KEYS[i]);
+        return JSON.stringify(r);
+      })(${JSON.stringify(selector)})`,
+            returnByValue: true,
+        }).catch(() => ({ result: { value: null } }));
+        if (fallbackRes?.value) {
+            try {
+                computedStylesData = JSON.parse(fallbackRes.value);
+            }
+            catch { }
+        }
+    }
+    let listeners = [];
+    try {
+        const resolved = await DOM.resolveNode({ nodeId: resolvedNodeId });
+        if (resolved.object?.objectId) {
+            const evtRes = await DOMDebugger.getEventListeners({ objectId: resolved.object.objectId, depth: 1, pierce: true }).catch(() => null);
+            if (evtRes?.listeners) {
+                listeners = evtRes.listeners.map(l => ({ type: l.type, useCapture: l.useCapture, passive: l.passive }));
+            }
+        }
+    }
+    catch (e) {
+        // Ignore DOMDebugger errors
+    }
+    const data = {
+        boxModel: boxModel?.model ? {
+            width: boxModel.model.width,
+            height: boxModel.model.height,
+            content: boxModel.model.content,
+        } : null,
+        computedStyles: computedStylesData,
+        eventListeners: listeners
+    };
+    return { success: true, data, message: "Inspected element successfully" };
+}

package/dist/tools/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map