@weavetab/mcp 2.5.0 → 2.5.1

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

@@ -1,4 +0,0 @@
-import type { GithubToolError } from "./repoContext.js";
-export declare function canMakeApiCall(): true | GithubToolError;
-export declare function recordApiCall(headers: Headers): void;
-export declare function handleApiResponse(response: Response): Response | GithubToolError;

package/dist/tools/github/rateLimiter.js

@@ -1,46 +0,0 @@
-let state = {
-    remaining: 60,
-    resetAt: null,
-};
-const SAFETY_THRESHOLD = 5;
-export function canMakeApiCall() {
-    const nowSec = Math.floor(Date.now() / 1000);
-    if (state.resetAt && nowSec >= state.resetAt) {
-        // We've passed the reset window, assume we have quota again
-        state.remaining = 60;
-        state.resetAt = null;
-    }
-    if (state.remaining < SAFETY_THRESHOLD) {
-        const resetTime = state.resetAt ? new Date(state.resetAt * 1000).toISOString() : "unknown";
-        return {
-            error: "RATE_LIMIT_LOW",
-            message: `GitHub API hourly rate limit is too low (remaining: ${state.remaining}). Please wait until ${resetTime} before making more API calls. Note: github_read does NOT consume API calls.`,
-            remaining: state.remaining,
-            reset_at: state.resetAt
-        };
-    }
-    return true;
-}
-export function recordApiCall(headers) {
-    const remainingStr = headers.get("x-ratelimit-remaining");
-    const resetStr = headers.get("x-ratelimit-reset");
-    if (remainingStr) {
-        state.remaining = parseInt(remainingStr, 10) || state.remaining;
-    }
-    if (resetStr) {
-        state.resetAt = parseInt(resetStr, 10) || state.resetAt;
-    }
-}
-export function handleApiResponse(response) {
-    recordApiCall(response.headers);
-    if (response.status === 403 || response.status === 429) {
-        const resetTime = state.resetAt ? new Date(state.resetAt * 1000).toISOString() : "unknown";
-        return {
-            error: "RATE_LIMIT_EXCEEDED",
-            message: `GitHub API rate limit exceeded. Please wait until ${resetTime}.`,
-            remaining: state.remaining,
-            reset_at: state.resetAt
-        };
-    }
-    return response;
-}

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

@@ -1,34 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../../config/loader.js";
-export declare function githubRead(session: CDP.Client, args: {
-    repo?: string;
-    paths: string[];
-    line_range?: [number, number];
-}, config: Config): Promise<import("./repoContext.js").GithubToolError | {
-    warnings: string[] | undefined;
-    files: ({
-        path: string;
-        error: string;
-        status: number;
-        message: string;
-        total_lines?: undefined;
-        truncated?: undefined;
-        content?: undefined;
-    } | {
-        path: string;
-        total_lines: number;
-        truncated: boolean;
-        content: string;
-        error?: undefined;
-        status?: undefined;
-        message?: undefined;
-    } | {
-        path: string;
-        error: string;
-        message: any;
-        status?: undefined;
-        total_lines?: undefined;
-        truncated?: undefined;
-        content?: undefined;
-    })[];
-}>;

package/dist/tools/github/read.js

@@ -1,74 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,129 +0,0 @@
-/**
- * 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/hover.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,57 +0,0 @@
-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/integration.test.d.ts

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

package/dist/tools/integration.test.js

@@ -1,96 +0,0 @@
-/**
- * integration.test.ts — Phase 1.1
- * Integration tests for click, type, and browser_map against real pages.
- * Run: npx tsx src/tools/integration.test.ts
- */
-import { loadConfigSync } from "../config/loader.js";
-import { getOrConnect } from "../cdp/connector.js";
-import { weaveClick } from "./click.js";
-import { weaveType } from "./type.js";
-import { browserMap } from "./read.js";
-import { buildActionMap } from "../cdp/walker.js";
-const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-let passed = 0, failed = 0;
-const assert = (cond, msg) => {
-    if (cond) {
-        console.error(`  ✅ ${msg}`);
-        passed++;
-    }
-    else {
-        console.error(`  ❌ ${msg}`);
-        failed++;
-    }
-};
-async function main() {
-    const config = loadConfigSync();
-    const client = await getOrConnect(config);
-    const session = client.session;
-    // ── Test 1: browser_map returns ref IDs ────────────
-    console.error("\n── Test 1: browser_map returns ref IDs ──");
-    await session.Page.navigate({ url: "https://httpbin.org/forms/post" });
-    await sleep(3000);
-    const mapStr = await browserMap(session, { prune: true }, "default", config);
-    assert(typeof mapStr === "string" && mapStr.length > 80, "map returned markdown content");
-    const rawMap = await buildActionMap(session, { prune: true }, "default");
-    assert(rawMap.elements.length >= 3, "map has >= 3 elements");
-    const allValid = rawMap.elements.filter(Boolean).every(el => el.id && String(el.id).startsWith("w:"));
-    assert(allValid, "all elements have w: ref IDs");
-    // ── Test 2: weaveClick by label ────────────────────
-    console.error("\n── Test 2: weaveClick by label ──");
-    await session.Page.navigate({ url: "https://httpbin.org/forms/post" });
-    await sleep(3000);
-    const clickR = await weaveClick(session, { label: "Submit order" }, config);
-    assert(clickR.success === true, "click returned success");
-    assert(typeof clickR.clicked === "string" && clickR.clicked.length > 0, "clicked field set");
-    assert(typeof clickR.ref === "string" && clickR.ref.startsWith("w:"), "ref is w:NN format");
-    assert(typeof clickR.execution_ms === "number" && clickR.execution_ms > 0, "execution_ms > 0");
-    // ── Test 3: weaveType by ref ID ────────────────────
-    console.error("\n── Test 3: weaveType by ref ID ──");
-    await session.Page.navigate({ url: "https://httpbin.org/forms/post" });
-    await sleep(3000);
-    const elems = await buildActionMap(session, { prune: true }, "default");
-    const textbox = elems.elements.find(el => el.role === "textbox" || (el.role === "input" && !el.type));
-    if (textbox?.id) {
-        const typeR = await weaveType(session, { id: textbox.id, text: "Hello" }, config);
-        assert(typeR.success === true, "type returned success");
-        assert(typeof typeR.length === "number" && typeR.length > 0, "length > 0");
-        assert(typeof typeR.typed_into === "string", "typed_into is string");
-        assert(typeof typeR.execution_ms === "number" && typeR.execution_ms > 0, "execution_ms > 0");
-    }
-    else {
-        assert(true, "no text input found (skip)");
-    }
-    // ── Test 4: weaveClick by ref ID ───────────────────
-    console.error("\n── Test 4: weaveClick by ref ID ──");
-    await session.Page.navigate({ url: "https://httpbin.org/forms/post" });
-    await sleep(3000);
-    const map2 = await buildActionMap(session, { prune: true }, "default");
-    const btn = map2.elements.find(r => r.role === "button");
-    if (btn?.id) {
-        const refR = await weaveClick(session, { id: btn.id }, config);
-        assert(refR.success === true, "ref-ID click returned success");
-        assert(refR.ref === btn.id, "click.ref matches input ref");
-    }
-    else {
-        assert(true, "no button found (skip)");
-    }
-    // ── Test 5: Stuck detection on nonexistent element ─
-    console.error("\n── Test 5: Stuck detection ──");
-    const stuckR = await weaveClick(session, { label: "__nonexistent__" }, config);
-    if (stuckR.success) {
-        assert(stuckR.stuck_warning === true, "nonexistent click reports stuck_warning");
-    }
-    else {
-        assert(true, "nonexistent click correctly fails");
-    }
-    // ── Summary ────────────────────────────────────────
-    console.error(`\nResults: ${passed} passed, ${failed} failed`);
-    await session.close().catch(() => { });
-    if (failed > 0)
-        process.exit(1);
-    else
-        console.error("ALL INTEGRATION TESTS PASSED");
-    process.exit(0);
-}
-main();
-//# sourceMappingURL=integration.test.js.map

package/dist/tools/macro_compiler.d.ts

@@ -1,7 +0,0 @@
-import type { TrailEntry as TrailStep } from "../intelligence/trail.js";
-import type { AnyBurstStep } from "./burst.js";
-/**
- * Compiles a sequence of successful trail steps into a single burst macro.
- * This skips intermediate DOM reads for faster execution.
- */
-export declare function compileTraceToMacro(steps: TrailStep[]): AnyBurstStep[];

package/dist/tools/macro_compiler.js

@@ -1,82 +0,0 @@
-import { logDebug } from "../audit/logger.js";
-/**
- * Universal parameter extractor — tries ALL known parameter key patterns plus
- * runtime introspection to find the args container regardless of the source
- * code path that produced the trail entry.
- */
-function extractArgs(step) {
-    const s = step;
-    // 1. Known parameter key patterns (ordered by specificity)
-    const knownKeys = [
-        'arguments', 'args', 'mcp_arguments', 'input',
-        'params', 'parameters', 'tool_args', 'toolInput',
-        'data', 'payload', 'options',
-    ];
-    for (const key of knownKeys) {
-        const val = s[key];
-        if (val !== null && val !== undefined && typeof val === 'object' && !Array.isArray(val)) {
-            return val;
-        }
-    }
-    // 2. Runtime introspection: find the first own property that looks like
-    // a params container (non-null object, not a standard metadata key).
-    const metaKeys = new Set([
-        'tool', 'result', 'timestamp', 'type', 'id',
-        'status', 'error', 'duration', 'startTime', 'endTime',
-        'session', 'tabId', 'targetId',
-    ]);
-    for (const key of Object.keys(s)) {
-        if (metaKeys.has(key))
-            continue;
-        const val = s[key];
-        if (val !== null && val !== undefined && typeof val === 'object' && !Array.isArray(val)) {
-            logDebug(`[macro_compiler] Found unknown param key "${key}" on step ${step.tool}`);
-            return val;
-        }
-    }
-    // 3. Totally empty — log the shape for debugging
-    logDebug(`[macro_compiler] Could not extract args from step ${step.tool}, shape: ${Object.keys(s).join(',')}`);
-    return {};
-}
-/**
- * Compiles a sequence of successful trail steps into a single burst macro.
- * This skips intermediate DOM reads for faster execution.
- */
-export function compileTraceToMacro(steps) {
-    const macro = [];
-    let lastKey = "";
-    const BURST_TOOLS = new Set([
-        "browser_click", "browser_type", "browser_navigate", "browser_go",
-        "browser_key", "browser_scroll", "browser_wait", "browser_select",
-        "browser_pointer", "browser_eval", "browser_console", "browser_find",
-        "browser_fill", "browser_type_secret", "browser_inspect",
-        "browser_screenshot", "browser_storage", "browser_cookies",
-        "browser_highlight", "browser_scrape",
-        "browser_canvas", "browser_performance", "browser_snapshot",
-        "browser_pdf", "browser_dialog", "browser_upload", "browser_automation",
-        "browser_viewport", "browser_clipboard", "browser_detect",
-        "browser_macro_compile", "browser_reset_loop_counter", "browser_recording",
-        "browser_fill", "type_and_send", "navigate_and_read",
-        "click_and_wait", "scroll_and_read",
-    ]);
-    steps.forEach((step, idx) => {
-        if (step.result && !step.result.success)
-            return;
-        if (step.tool === "browser_map") {
-            if (idx === steps.length - 1) {
-                macro.push({ tool: "browser_map", args: step.input || {} });
-            }
-            return;
-        }
-        if (BURST_TOOLS.has(step.tool)) {
-            const args = extractArgs(step);
-            // Dedupe consecutive identical steps (same tool + same args)
-            const key = `${step.tool}:${JSON.stringify(args)}`;
-            if (key !== lastKey) {
-                macro.push({ tool: step.tool, args });
-                lastKey = key;
-            }
-        }
-    });
-    return macro;
-}

package/dist/tools/mouse.d.ts

@@ -1,21 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-export interface MouseResult {
-    success: true;
-    action: string;
-    x: number;
-    y: number;
-    end_x?: number;
-    end_y?: number;
-    execution_ms: number;
-    tab_id: string;
-    url: string;
-}
-export declare function browserMouse(session: CDP.Client, args: {
-    action: "hover" | "click" | "double_click" | "drag_and_drop";
-    x: number;
-    y: number;
-    end_x?: number;
-    end_y?: number;
-}, config: Config): Promise<MouseResult>;
-//# sourceMappingURL=mouse.d.ts.map

package/dist/tools/mouse.js

@@ -1,62 +0,0 @@
-import { logAction } from "../audit/logger.js";
-import { recordAction } from "../intelligence/trail.js";
-import { ghostMove } from "../overlay/ghost.js";
-import { waitForDOMStable } from "../sensors/guard.js";
-export async function browserMouse(session, args, config) {
-    const { action, x, y, end_x, end_y } = args;
-    const startMs = Date.now();
-    const { Page, Input } = session;
-    const { frameTree } = await Page.getFrameTree();
-    const url = frameTree.frame.url;
-    let targetId = "default";
-    const { sessionRegistry } = await import("../state/session.js");
-    const active = sessionRegistry.getActive();
-    if (active)
-        targetId = active.targetId;
-    // Move to target using human-like motion (no label — avoids fake "scanning" delay)
-    await ghostMove(session, x, y, config);
-    if (action === "click") {
-        await Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
-        await Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
-    }
-    else if (action === "double_click") {
-        await Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
-        await Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
-        await new Promise(r => setTimeout(r, 100));
-        await Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 2 });
-        await Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 2 });
-    }
-    else if (action === "drag_and_drop") {
-        if (end_x === undefined || end_y === undefined) {
-            throw new Error("drag_and_drop requires end_x and end_y");
-        }
-        await Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
-        await new Promise(r => setTimeout(r, 200));
-        // Drag to destination
-        await ghostMove(session, end_x, end_y, config);
-        await new Promise(r => setTimeout(r, 200));
-        await Input.dispatchMouseEvent({ type: "mouseReleased", x: end_x, y: end_y, button: "left", clickCount: 1 });
-    }
-    // Settle
-    await waitForDOMStable(session, 50, 1500).catch(() => { });
-    const executionMs = Date.now() - startMs;
-    logAction("browser_mouse", action, `(${x}, ${y}) (exec: ${executionMs}ms)`);
-    recordAction({
-        timestamp: new Date().toISOString(),
-        tool: "browser_mouse",
-        input: args,
-        result: { success: true },
-    });
-    return {
-        success: true,
-        action,
-        x,
-        y,
-        end_x,
-        end_y,
-        execution_ms: executionMs,
-        tab_id: targetId,
-        url,
-    };
-}
-//# sourceMappingURL=mouse.js.map