@weavetab/mcp 2.5.0-beta.0

package/dist/tools/burst.js

@@ -0,0 +1,344 @@
+/**
+ * Weavetab — tools/burst.ts
+ * Executes multiple tool calls serially in one round-trip, with per-step delta checking.
+ * Weavetab by fy2ne
+ */
+import { weaveClick } from "./click.js";
+import { weaveType } from "./type.js";
+import { weaveNavigate } from "./navigate.js";
+import { weaveKey } from "./key.js";
+import { browserScroll } from "./scroll.js";
+import { browserWait } from "./wait.js";
+import { browserMap } from "./read.js";
+import { browserEval } from "./eval.js";
+import { browserSelect } from "./select.js";
+import { browserPointer } from "./pointer.js";
+import { browserConsole } from "./console.js";
+import { browserFind } from "./find.js";
+import { browserFill } from "./fill.js";
+import { weaveTypeSecret } from "./type_secret.js";
+import { browserInspect } from "./inspect.js";
+import { browserStorage } from "./storage.js";
+import { browserCookies } from "./cookies.js";
+import { browserHighlight } from "./highlight.js";
+import { browserScrape } from "./scrape.js";
+import { logAction } from "../audit/logger.js";
+import { cacheActionMap } from "../state/cache.js";
+import { buildActionMap } from "../cdp/walker.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId, getConfigBrowserType } from "../config/loader.js";
+import { sendToExtension } from "../cdp/helpers.js";
+import { resetLoopCounter } from "../intelligence/trail.js";
+/**
+ * Expand a macro step into primitive BurstSteps.
+ */
+function expandMacro(step) {
+    if (step.tool === "type_and_send") {
+        const { x, y, text, id, label, pressEnter = true } = step.args;
+        if (!id && !label && x === undefined && y === undefined) {
+            throw new Error("type_and_send macro failed: no target specified (requires id, label, or x/y)");
+        }
+        if (text === undefined) {
+            throw new Error("type_and_send macro failed: text argument is required");
+        }
+        const typeArgs = { text, noRetry: true };
+        if (x !== undefined)
+            typeArgs.x = x;
+        if (y !== undefined)
+            typeArgs.y = y;
+        if (id)
+            typeArgs.id = id;
+        if (label)
+            typeArgs.label = label;
+        const steps = [{ tool: "browser_type", args: typeArgs }];
+        if (pressEnter)
+            steps.push({ tool: "browser_key", args: { key: "Enter" } });
+        return steps;
+    }
+    if (step.tool === "navigate_and_read") {
+        const { url } = step.args;
+        return [
+            { tool: "browser_go", args: { url } },
+            { tool: "browser_map", args: {} },
+        ];
+    }
+    if (step.tool === "click_and_wait") {
+        const { id, label, wait_for, wait_value, x, y } = step.args;
+        const clickArgs = {};
+        if (id)
+            clickArgs.id = id;
+        if (label)
+            clickArgs.label = label;
+        if (x !== undefined)
+            clickArgs.x = x;
+        if (y !== undefined)
+            clickArgs.y = y;
+        clickArgs.waitForNetwork = true;
+        clickArgs.waitAfter = 500;
+        return [
+            { tool: "browser_click", args: clickArgs },
+        ];
+    }
+    if (step.tool === "scroll_and_read") {
+        const { direction, distance } = step.args;
+        return [
+            { tool: "browser_scroll", args: { direction, distance } },
+            { tool: "browser_map", args: {} },
+        ];
+    }
+    if (step.tool === "fill_form") {
+        const { fields, submit } = step.args;
+        const steps = [];
+        if (fields && typeof fields === "object") {
+            for (const [id, value] of Object.entries(fields)) {
+                steps.push({ tool: "browser_fill", args: { id, value } });
+            }
+        }
+        if (submit) {
+            steps.push({ tool: "browser_key", args: { key: "Enter" } });
+        }
+        return steps;
+    }
+    if (step.tool === "drag_and_drop") {
+        const { id, end_id, x, y, end_x, end_y, label } = step.args;
+        const pointerArgs = { action: "drag_and_drop" };
+        if (id)
+            pointerArgs.ref = id;
+        if (end_id)
+            pointerArgs.end_ref = end_id;
+        if (label)
+            pointerArgs.label = label;
+        if (x !== undefined)
+            pointerArgs.x = x;
+        if (y !== undefined)
+            pointerArgs.y = y;
+        if (end_x !== undefined)
+            pointerArgs.end_x = end_x;
+        if (end_y !== undefined)
+            pointerArgs.end_y = end_y;
+        return [{ tool: "browser_pointer", args: pointerArgs }];
+    }
+    if (step.tool === "hover_and_read") {
+        const { id, label, x, y, holdMs = 300 } = step.args;
+        const pointerArgs = { action: "hover", holdMs };
+        if (id)
+            pointerArgs.ref = id;
+        if (label)
+            pointerArgs.label = label;
+        if (x !== undefined)
+            pointerArgs.x = x;
+        if (y !== undefined)
+            pointerArgs.y = y;
+        return [
+            { tool: "browser_pointer", args: pointerArgs },
+            { tool: "browser_map", args: {} },
+        ];
+    }
+    return [];
+}
+export async function browserBurst(session, args, config) {
+    if (!args.steps || args.steps.length === 0) {
+        return { success: true, steps_completed: 0, results: [], aborted: false };
+    }
+    // Expand macro steps into primitive steps first
+    const steps = [];
+    const MACRO_TOOLS = new Set(["type_and_send", "navigate_and_read", "click_and_wait", "scroll_and_read", "fill_form", "drag_and_drop", "hover_and_read"]);
+    for (const step of args.steps) {
+        if (MACRO_TOOLS.has(step.tool)) {
+            steps.push(...expandMacro(step));
+        }
+        else {
+            steps.push({
+                tool: step.tool,
+                args: JSON.parse(JSON.stringify(step.args || {}))
+            });
+        }
+    }
+    const { batch } = args;
+    // Inject fast: true if batch mode is on, unless explicitly set to false
+    if (batch) {
+        for (const step of steps) {
+            if (step.args.fast === undefined) {
+                step.args.fast = true;
+            }
+        }
+    }
+    const results = [];
+    let stepsCompleted = 0;
+    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: `running ${steps.length} steps ${batch ? 'in batch' : 'in sequence'}...` } });
+    resetLoopCounter("burst");
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        let result;
+        let stepError;
+        try {
+            switch (step.tool) {
+                case "browser_click":
+                    result = await weaveClick(session, step.args, config);
+                    break;
+                case "browser_type":
+                    result = await weaveType(session, step.args, config);
+                    break;
+                case "browser_go":
+                    result = await weaveNavigate(session, step.args.url, config);
+                    break;
+                case "browser_key":
+                    result = await weaveKey(session, step.args, config);
+                    break;
+                case "browser_scroll":
+                    result = await browserScroll(session, step.args, config);
+                    break;
+                case "browser_wait":
+                    result = await browserWait(session, step.args, config);
+                    break;
+                case "browser_map": {
+                    const mapTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId || "default";
+                    result = await browserMap(session, step.args, mapTargetId, config);
+                    break;
+                }
+                case "browser_eval":
+                    result = await browserEval(session, step.args, config);
+                    break;
+                case "browser_select":
+                    result = await browserSelect(session, step.args, config);
+                    break;
+                case "browser_pointer":
+                    result = await browserPointer(session, step.args, config);
+                    break;
+                case "browser_console": {
+                    let targetId = "default";
+                    const active = sessionRegistry.getActive(getConfigAgentId(config));
+                    if (active)
+                        targetId = active.targetId;
+                    result = await browserConsole(session, step.args, config, targetId);
+                    break;
+                }
+                case "browser_find":
+                    result = await browserFind(session, step.args, config);
+                    break;
+                case "browser_fill":
+                    result = await browserFill(session, step.args, config);
+                    break;
+                case "browser_navigate":
+                    result = await weaveNavigate(session, step.args.url, config);
+                    break;
+                case "browser_type_secret":
+                    result = await weaveTypeSecret(session, step.args, config);
+                    break;
+                case "browser_screenshot": {
+                    const { browserScreenshot } = await import("./screenshot.js");
+                    result = await browserScreenshot(session, step.args, config);
+                    break;
+                }
+                case "browser_inspect":
+                    result = await browserInspect(session, step.args, config);
+                    break;
+                case "browser_storage":
+                    result = await browserStorage(session, step.args, config);
+                    break;
+                case "browser_cookies":
+                    result = await browserCookies(session, step.args, config);
+                    break;
+                case "browser_highlight":
+                    result = await browserHighlight(session, step.args, config);
+                    break;
+                case "browser_scrape":
+                    result = await browserScrape(session, step.args, config);
+                    break;
+                case "browser_canvas": {
+                    const { browserCanvas } = await import("./canvas.js");
+                    result = await browserCanvas(session, step.args, config);
+                    break;
+                }
+                case "browser_performance": {
+                    const { browserPerformance } = await import("./performance.js");
+                    result = await browserPerformance(session, config);
+                    break;
+                }
+                case "browser_snapshot": {
+                    const { browserSnapshot } = await import("./snapshot.js");
+                    result = await browserSnapshot(session, step.args, config);
+                    break;
+                }
+                case "browser_pdf": {
+                    const { browserPdf } = await import("./pdf.js");
+                    result = await browserPdf(session, step.args, config);
+                    break;
+                }
+                case "browser_dialog": {
+                    const { browserDialog } = await import("./dialog.js");
+                    result = await browserDialog(session, step.args);
+                    break;
+                }
+                case "browser_upload": {
+                    const { browserUpload } = await import("./upload.js");
+                    result = await browserUpload(session, step.args, config);
+                    break;
+                }
+                case "browser_viewport": {
+                    const { browserViewport } = await import("./viewport.js");
+                    result = await browserViewport(session, step.args, config);
+                    break;
+                }
+                case "browser_clipboard": {
+                    const { browserClipboard } = await import("./clipboard.js");
+                    result = await browserClipboard(session, step.args, config);
+                    break;
+                }
+                case "browser_detect": {
+                    const { detectBrowsers } = await import("./browser_detect.js");
+                    result = detectBrowsers(getConfigBrowserType(config));
+                    break;
+                }
+                case "browser_recording": {
+                    const { browserRecording } = await import("./recording.js");
+                    result = await browserRecording(session, step.args, config);
+                    break;
+                }
+                case "browser_automation": {
+                    const { browserAutomation } = await import("./automation.js");
+                    result = await browserAutomation(session, step.args, config);
+                    break;
+                }
+                default:
+                    stepError = `Unknown tool "${step.tool}"`;
+            }
+            if (stepError) {
+                results.push({ step: i + 1, tool: step.tool, success: false, error: stepError });
+                stepsCompleted++;
+                logAction("browser_burst", `step_${i + 1}`, `error: ${stepError}`);
+                continue;
+            }
+            const resultObj = result && typeof result === "object" ? result : {};
+            const isError = resultObj.success === false;
+            results.push({
+                step: i + 1,
+                tool: step.tool,
+                success: !isError,
+                result: isError ? undefined : result,
+                error: isError ? resultObj.message || resultObj.stuck_hint || undefined : undefined,
+            });
+            stepsCompleted++;
+        }
+        catch (err) {
+            logAction("browser_burst", `step_${i + 1}`, `exception: ${err?.message ?? err}`);
+            results.push({ step: i + 1, tool: step.tool, success: false, error: `Exception: ${err?.message ?? String(err)}` });
+            stepsCompleted++;
+        }
+        logAction("browser_burst", `step_${i + 1}/${steps.length}`, step.tool);
+    }
+    // If batch was used, update cache once at the end
+    if (batch) {
+        const targetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId || "default";
+        const map = await buildActionMap(session, { lite: true }, targetId);
+        cacheActionMap(targetId, map);
+    }
+    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } });
+    const anySuccess = results.some(r => r.success);
+    return {
+        success: anySuccess,
+        steps_completed: stepsCompleted,
+        results,
+        aborted: false,
+    };
+}

package/dist/tools/canvas.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Weavetab — tools/canvas.ts
+ * browser_canvas: Extract canvas image data as base64 or dispatch raw stroke/drawing events.
+ * Supports ref resolution via action map cache and CDP DOM APIs.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface CanvasOptions {
+    action: "get_image" | "draw";
+    selector?: string;
+    id?: string;
+    label?: string;
+    ref?: string;
+    backendNodeId?: number;
+    points?: {
+        x: number;
+        y: number;
+    }[];
+}
+export declare function browserCanvas(session: CDP.Client, options: CanvasOptions, _config: Config): Promise<{
+    success: boolean;
+    dataUrl?: string;
+    message: string;
+}>;

package/dist/tools/canvas.js

@@ -0,0 +1,132 @@
+import { getConfigAgentId } from "../config/loader.js";
+import { ghostClick } from "../overlay/ghost.js";
+async function resolveCanvasBackendNodeId(session, options, _config) {
+    if (options.backendNodeId)
+        return options.backendNodeId;
+    const refId = options.ref || options.id;
+    if (!refId)
+        return undefined;
+    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 numericId = parseInt(refId.replace(/^w:/, ""), 10);
+            const el = cachedMap.elements.find((e) => {
+                const n = parseInt(String(e.id).replace(/^w:/, ""), 10);
+                return n === numericId;
+            });
+            if (el?.backendNodeId)
+                return el.backendNodeId;
+        }
+    }
+    catch { /* cache miss — fall through */ }
+    return undefined;
+}
+async function resolveCanvasViaCDP(session, backendNodeId) {
+    const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [backendNodeId] });
+    if (!nodeIds?.[0])
+        throw new Error("Canvas backendNodeId could not be resolved");
+    const { object } = await session.DOM.resolveNode({ nodeId: nodeIds[0] });
+    if (!object?.objectId)
+        throw new Error("Could not resolve canvas node to object");
+    const { result } = await session.Runtime.callFunctionOn({
+        objectId: object.objectId,
+        functionDeclaration: `function() {
+      var rect = this.getBoundingClientRect();
+      return JSON.stringify({
+        x: rect.left,
+        y: rect.top,
+        dataUrl: this.toDataURL('image/png')
+      });
+    }()`,
+        returnByValue: true,
+    });
+    return JSON.parse(result.value);
+}
+async function resolveCanvasViaSelector(session, options, targetId) {
+    let selector;
+    if (options.selector) {
+        selector = options.selector;
+    }
+    else if (options.id) {
+        selector = `[data-wt-id="${options.id.replace(/^w:/, "")}"]`;
+    }
+    else if (options.label) {
+        selector = `canvas[aria-label="${options.label.replace(/"/g, '\\"')}"], canvas[title="${options.label.replace(/"/g, '\\"')}"]`;
+    }
+    else if (options.ref) {
+        selector = `[data-wt-id="${options.ref.replace(/^w:/, "")}"]`;
+    }
+    else {
+        selector = "canvas";
+    }
+    const { omniEvaluate } = await import("../cdp/omni_broker.js");
+    const raw = await omniEvaluate(session, targetId, `(function() {
+      let el;
+      try { el = document.querySelector(${JSON.stringify(selector)}); } catch(e) { el = null; }
+      // Skip extension overlay canvases
+      if (el && (el.closest('[data-wt-overlay]') || el.closest('.weavetab-overlay') || el.id === '__wt_ghost_canvas')) {
+        var total = document.querySelectorAll('canvas').length;
+        return JSON.stringify({ error: 'Selector matched a WeaveTab overlay canvas (hidden). Found ' + total + ' <canvas> element(s) on page — try a more specific selector or use nodeId.', exists: false });
+      }
+      if (!el) {
+        var total = document.querySelectorAll('canvas').length;
+        if (total === 0) return JSON.stringify({ error: 'No <canvas> elements found on this page.', exists: false });
+        return JSON.stringify({ error: 'Selector did not match any element. Found ' + total + ' <canvas> element(s) on page — try a more specific selector or use nodeId.', exists: false });
+      }
+      if (el.tagName !== 'CANVAS') return JSON.stringify({ error: 'Element is not a <canvas> — found <' + el.tagName.toLowerCase() + '> instead.', exists: false });
+      var r = el.getBoundingClientRect();
+      return JSON.stringify({ x: r.left, y: r.top, dataUrl: el.toDataURL('image/png'), exists: true });
+    })()`);
+    const parsed = JSON.parse(raw || "{}");
+    if (parsed.error)
+        throw new Error(parsed.error);
+    return parsed;
+}
+export async function browserCanvas(session, options, _config) {
+    const { action, points } = options;
+    const backendNodeId = await resolveCanvasBackendNodeId(session, options, _config);
+    const { sessionRegistry } = await import("../state/session.js");
+    const activeClient = sessionRegistry.getActive(getConfigAgentId(_config));
+    const targetId = activeClient?.targetId || "default";
+    let rect;
+    if (backendNodeId) {
+        try {
+            rect = await resolveCanvasViaCDP(session, backendNodeId);
+        }
+        catch {
+            rect = await resolveCanvasViaSelector(session, options, targetId);
+        }
+    }
+    else {
+        rect = await resolveCanvasViaSelector(session, options, targetId);
+    }
+    if (action === "get_image") {
+        return { success: true, dataUrl: rect.dataUrl, message: `Canvas extracted` };
+    }
+    else if (action === "draw") {
+        if (!points || points.length === 0) {
+            throw new Error("draw action requires an array of points");
+        }
+        const { Input } = session;
+        const { x: offsetX, y: offsetY } = rect;
+        const startX = offsetX + points[0].x;
+        const startY = offsetY + points[0].y;
+        await Input.dispatchMouseEvent({ type: "mouseMoved", x: startX, y: startY });
+        await ghostClick(session, startX, startY);
+        for (let i = 1; i < points.length; i++) {
+            const ptX = offsetX + points[i].x;
+            const ptY = offsetY + points[i].y;
+            await Input.dispatchMouseEvent({ type: "mouseMoved", x: ptX, y: ptY, button: "left" });
+            await new Promise(r => setTimeout(r, 10));
+        }
+        const lastX = offsetX + points[points.length - 1].x;
+        const lastY = offsetY + points[points.length - 1].y;
+        await Input.dispatchMouseEvent({ type: "mouseReleased", x: lastX, y: lastY, button: "left", clickCount: 1 });
+        return { success: true, message: `Drew ${points.length} points on canvas` };
+    }
+    throw new Error("Unknown action");
+}

package/dist/tools/captcha.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Weavetab — tools/captcha.ts
+ * Dedicated browser_captcha tool for autonomous CAPTCHA detection and solving.
+ *
+ * Actions:
+ *   detect        → Identify CAPTCHA type, interaction method, and confidence
+ *   solve         → Attempt full autonomous solve (slider drag, hold, checkbox, invisible)
+ *   wait_for_user → Show HUD prompt and poll until CAPTCHA is gone (120s timeout)
+ *   status        → Quick check: is a CAPTCHA currently blocking?
+ *
+ * Zero API keys. All solving via CDP mouse simulation.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface CaptchaToolResult {
+    success: boolean;
+    action: string;
+    captcha_detected: boolean;
+    captcha_type?: string;
+    interaction_type?: string;
+    difficulty?: string;
+    confidence?: number;
+    /** True only when human input is truly required after all automated attempts */
+    human_needed: boolean;
+    solved?: boolean;
+    solve_method?: string;
+    message: string;
+    /** Specific instructions for the user when human_needed is true */
+    user_instructions?: string;
+    /** What the agent should do next */
+    next_action?: string;
+    execution_ms: number;
+}
+export declare function browserCaptcha(session: CDP.Client, args: {
+    action: "detect" | "solve" | "wait_for_user" | "status";
+    timeout?: number;
+}, _config: Config): Promise<CaptchaToolResult>;