@weavetab/mcp 2.5.0-beta.0

package/dist/tools/integration.test.js

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

@@ -0,0 +1,25 @@
+/**
+ * Weavetab — tools/key.ts
+ * Keyboard event dispatcher with allowlisted control keys and modifier support.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+import type { WeaveError } from "./click.js";
+type Modifier = "Alt" | "Ctrl" | "Meta" | "Shift";
+interface KeyResult {
+    success: true;
+    pressed: string;
+    tab_id: string;
+    url: string;
+    title: string;
+    url_changed?: boolean;
+    dom_changed?: boolean;
+    stuck_warning?: boolean;
+    stuck_hint?: string;
+}
+export declare function weaveKey(session: CDP.Client, args: {
+    key: string;
+    modifiers?: Modifier[];
+}, _config: Config): Promise<KeyResult | WeaveError>;
+export {};

package/dist/tools/key.js

@@ -0,0 +1,173 @@
+/**
+ * Weavetab — tools/key.ts
+ * Keyboard event dispatcher with allowlisted control keys and modifier support.
+ * Weavetab by fy2ne
+ */
+import { recordAction } from "../intelligence/trail.js";
+import { waitForDOMStable } from "../sensors/guard.js";
+import { waitForNetworkIdle } from "../sensors/wait.js";
+import { buildActionMap, toRefEntries } from "../cdp/walker.js";
+import { cacheActionMap, cacheBoxModel } from "../state/cache.js";
+import { computeDelta, storeSnapshot } from "../state/delta.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { sendToExtension } from "../cdp/helpers.js";
+const ALLOWED_KEYS = new Set([
+    "Enter", "Escape", "Tab", "Backspace", "Delete", "Space",
+    "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight",
+    "Home", "End", "PageUp", "PageDown",
+    "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+]);
+export async function weaveKey(session, args, _config) {
+    const { key, modifiers } = args;
+    // Allow single printable chars or control keys from the allowlist
+    if (key.length > 1 && !ALLOWED_KEYS.has(key)) {
+        return {
+            success: false,
+            error_code: "INVALID_KEY",
+            message: `[!] Key "${key}" is not a valid control key. Use single characters or: ${[...ALLOWED_KEYS].join(", ")}`,
+        };
+    }
+    let modMask = 0;
+    if (modifiers) {
+        if (modifiers.includes("Alt"))
+            modMask |= 1;
+        if (modifiers.includes("Ctrl"))
+            modMask |= 2;
+        if (modifiers.includes("Meta"))
+            modMask |= 4;
+        if (modifiers.includes("Shift"))
+            modMask |= 8;
+    }
+    const label = modifiers && modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: `pressing ${label}` } });
+    const { frameTree: beforeFrameTree } = await session.Page.getFrameTree();
+    const urlBefore = beforeFrameTree.frame.url;
+    // Track map before for delta if Enter is pressed
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(_config));
+    if (active)
+        targetId = active.targetId;
+    const mapBefore = await buildActionMap(session, { lite: true }, targetId);
+    storeSnapshot(targetId, urlBefore, toRefEntries(mapBefore.elements));
+    // We removed the direct toast injection here because the extension handles HUD display via Weavetab_STATE (line 66)
+    await session.Input.dispatchKeyEvent({ type: "rawKeyDown", key, modifiers: modMask, windowsVirtualKeyCode: key === "Enter" ? 13 : undefined, nativeVirtualKeyCode: key === "Enter" ? 13 : undefined });
+    if (key === "Enter") {
+        // SPA Fallback: direct form submit + submit button click for React/Vue/Google
+        // This is needed because Input.dispatchKeyEvent alone doesn't trigger SPA form submission
+        await session.Runtime.evaluate({ expression: `
+      (function(){
+        try {
+          var el = document.activeElement;
+          if (!el || !el.tagName) return;
+
+          // Focus the element first to make sure it's active
+          if (typeof el.focus === 'function') el.focus();
+
+          // 1. Try native form submit (Google search, DuckDuckGo, etc.)
+          var form = el.closest('form');
+          if (form) {
+            var submitBtn = form.querySelector('input[type="submit"], button[type="submit"]');
+            if (submitBtn && submitBtn.offsetParent !== null) { submitBtn.click(); return; }
+            try { form.submit(); return; } catch(e) {}
+          }
+
+          // 2. Google-specific: find name="q" input and submit its form
+          var q = document.querySelector('input[name="q"], textarea[name="q"]');
+          if (q) {
+            var qForm = q.closest('form');
+            if (qForm) { try { qForm.submit(); return; } catch(e) {} }
+          }
+
+          // 3. Last resort: find any visible submit/search button near the active element
+          var parent = el.parentElement;
+          while (parent && parent.tagName !== 'BODY') {
+            var btns = parent.querySelectorAll('button, input[type="submit"], input[type="button"]');
+            for (var i = 0; i < btns.length; i++) {
+              if (btns[i].offsetParent !== null && btns[i].getBoundingClientRect().width > 0) { btns[i].click(); return; }
+            }
+            parent = parent.parentElement;
+          }
+        } catch(e) {}
+      })();
+    ` }).catch(() => { });
+    }
+    await session.Input.dispatchKeyEvent({ type: "keyUp", key, modifiers: modMask, windowsVirtualKeyCode: key === "Enter" ? 13 : undefined, nativeVirtualKeyCode: key === "Enter" ? 13 : undefined });
+    // ── Post-Action Pipeline & Predictive Action Queue ────────────────────────
+    const predictiveQueue = async () => {
+        try {
+            const nextMap = await buildActionMap(session, { lite: true }, targetId);
+            cacheActionMap(targetId, nextMap);
+            for (const el of nextMap.elements.slice(0, 10)) {
+                if (el.backendNodeId) {
+                    const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [el.backendNodeId] }).catch(() => ({ nodeIds: [] }));
+                    if (nodeIds[0]) {
+                        const box = await session.DOM.getBoxModel({ nodeId: nodeIds[0] }).catch(() => null);
+                        if (box)
+                            cacheBoxModel(targetId, el.backendNodeId, box.model);
+                    }
+                }
+            }
+        }
+        catch { /* ignore pre-fetch errors */ }
+    };
+    const settleTimeout = key === "Enter" ? 5000 : 2500;
+    await Promise.all([
+        waitForDOMStable(session, 50, settleTimeout),
+        waitForNetworkIdle(session, 50, settleTimeout).catch(() => { }),
+        predictiveQueue()
+    ]);
+    // Post-key location context
+    let postUrl = "";
+    let postTitle = "";
+    try {
+        const { frameTree } = await session.Page.getFrameTree();
+        postUrl = frameTree.frame.url;
+        try {
+            const titleRes = await session.Runtime.evaluate({ expression: 'document.title', returnByValue: true });
+            postTitle = titleRes?.result?.value || postUrl;
+        }
+        catch {
+            postTitle = postUrl;
+        }
+        const activeSession = sessionRegistry.getActive(getConfigAgentId(_config));
+        if (activeSession) {
+            activeSession.url = postUrl;
+            activeSession.title = postTitle;
+        }
+    }
+    catch { /* ignore */ }
+    const urlChanged = postUrl !== urlBefore;
+    let domChanged = false;
+    let stuckWarning = false;
+    let stuckHint;
+    if (key === "Enter") {
+        const nextMap = await buildActionMap(session, { lite: true }, targetId);
+        const newRefs = toRefEntries(nextMap.elements);
+        const diff = computeDelta(targetId, urlBefore, newRefs);
+        const changedRefs = diff ? [...diff.added, ...diff.changed] : [];
+        domChanged = changedRefs.length > 0 || (diff?.removed.length ?? 0) > 0;
+        stuckWarning = !domChanged && !urlChanged;
+        if (stuckWarning) {
+            await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: 'hmm, no response. reassessing...' } });
+            stuckHint = "Page did not respond to Enter key. You might need to find the actual submit button and use browser_click instead.";
+        }
+    }
+    recordAction({
+        timestamp: new Date().toISOString(),
+        tool: "browser_key",
+        input: { key, modifiers },
+        result: { success: true, pressed: label },
+    });
+    return {
+        success: true,
+        pressed: label,
+        tab_id: targetId,
+        url: postUrl,
+        title: postTitle,
+        url_changed: urlChanged,
+        dom_changed: domChanged,
+        stuck_warning: stuckWarning,
+        ...(stuckHint ? { stuck_hint: stuckHint } : {})
+    };
+}

package/dist/tools/macro_compiler.d.ts

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

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

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

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

package/dist/tools/navigate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Weavetab — tools/navigate.ts
+ * URL navigation with domain blocklist enforcement and post-navigation DOM stability wait.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+import type { WeaveError } from "./click.js";
+interface NavigateResult {
+    success: true;
+    url: string;
+    title: string;
+    tab_id: string;
+}
+export declare function weaveNavigate(session: CDP.Client, url: string, config: Config, targetId?: string, force?: boolean, fast?: boolean): Promise<NavigateResult | WeaveError>;
+export {};