@weavetab/mcp 2.5.0-beta.0

package/dist/tools/dialog.js

@@ -0,0 +1,109 @@
+/**
+ * Weavetab — tools/dialog.ts
+ * Auto-handles JavaScript alert/confirm/prompt dialogs via CDP Page API.
+ * Weavetab by fy2ne
+ */
+import { logAction } from "../audit/logger.js";
+// Store the last dialog event data per session using a WeakMap. This survives
+// across initDialogHandler → browserDialog calls without leaking memory
+// (entries are GC'd when the session is released).
+const dialogState = new WeakMap();
+export function hasOpenDialog(session) {
+    const state = dialogState.get(session);
+    return state != null && !state.autoDismiss;
+}
+/** Register the auto-dismiss handler for the given CDP session. */
+export function initDialogHandler(session) {
+    session.Page.on("javascriptDialogOpening", async (event) => {
+        const { type, message, defaultPrompt } = event;
+        // Store dialog metadata WITHOUT auto-dismissing so browserDialog can read
+        // the type and handle it appropriately. This is the only point where CDP
+        // exposes the real type.
+        dialogState.set(session, { type, message, defaultPrompt, autoDismiss: false });
+        logAction("browser_dialog", type, `dialog detected: "${message}"`);
+        // Inject a visual toast so the user knows we detected it
+        const toastScript = `
+      (function() {
+        if (document.getElementById('wt-dialog-toast')) return;
+        const toast = document.createElement("div");
+        toast.id = 'wt-dialog-toast';
+        toast.style.cssText = "position:fixed;bottom:20px;right:20px;background:#f59e0b;color:white;padding:12px 24px;border-radius:8px;font-family:sans-serif;font-weight:600;z-index:2147483647;box-shadow:0 4px 12px rgba(0,0,0,0.3);animation:fadein 0.3s, fadeout 0.3s 2.5s forwards;";
+        toast.textContent = "${type} detected: ${message.substring(0, 50).replace(/"/g, '\\"')}";
+        const style = document.createElement("style");
+        style.textContent = "@keyframes fadein { from { opacity: 0; transform: translateY(20px); } to { opacity: 1; transform: translateY(0); } } @keyframes fadeout { from { opacity: 1; } to { opacity: 0; } }";
+        document.head.appendChild(style);
+        document.documentElement.appendChild(toast);
+        setTimeout(() => toast.remove(), 3000);
+      })();
+    `;
+        session.Runtime.evaluate({ expression: toastScript }).catch(() => { });
+        // For security-critical dialogs (like extension removal), auto-dismiss to prevent accidental acceptance
+        if (message.toLowerCase().includes("extension") || message.toLowerCase().includes("developer mode")) {
+            try {
+                await session.Page.handleJavaScriptDialog({ accept: false });
+                dialogState.set(session, { type, message, defaultPrompt, autoDismiss: true });
+                logAction("browser_dialog", type, `auto-dismissed security dialog: "${message}"`);
+            }
+            catch {
+                // Dialog may have already closed
+            }
+        }
+        else {
+            // For normal dialogs, leave them open for 5 seconds so browserDialog can handle them with the correct type
+            // After timeout, auto-dismiss to prevent blocking
+            const timeoutId = setTimeout(async () => {
+                const current = dialogState.get(session);
+                if (current && !current.autoDismiss) {
+                    try {
+                        await session.Page.handleJavaScriptDialog({ accept: false });
+                        dialogState.set(session, { type: current.type, message: current.message, defaultPrompt: current.defaultPrompt, autoDismiss: true });
+                        logAction("browser_dialog", current.type, `auto-dismissed after timeout: "${current.message}"`);
+                    }
+                    catch {
+                        // Dialog may have already been handled
+                    }
+                }
+            }, 5000);
+            const current = dialogState.get(session);
+            if (current) {
+                current.timeoutId = timeoutId;
+            }
+        }
+    });
+}
+export async function browserDialog(session, options) {
+    const { action, promptText } = options;
+    // Read stored dialog metadata before handling. If promptText was provided but
+    // the dialog type is 'prompt', pass it through so prompt injection works.
+    const stored = dialogState.get(session) || null;
+    // Clear the auto-dismiss timer immediately when browserDialog is called
+    if (stored?.timeoutId) {
+        clearTimeout(stored.timeoutId);
+    }
+    // Attempt to handle any currently open dialog
+    try {
+        await session.Page.handleJavaScriptDialog({
+            accept: action === "accept",
+            promptText: action === "accept"
+                ? (promptText !== undefined ? promptText : (stored?.type === "prompt" ? (stored?.defaultPrompt ?? "") : undefined))
+                : undefined,
+        });
+        // Mark as handled so the timeout handler doesn't try to dismiss it
+        if (stored) {
+            dialogState.set(session, { ...stored, autoDismiss: true });
+        }
+        // Clean up after a short delay
+        setTimeout(() => dialogState.delete(session), 100);
+    }
+    catch (e) {
+        // No dialog was open or it was already handled
+        dialogState.delete(session);
+    }
+    logAction("browser_dialog", "manual", `attempted to ${action} pending dialog`);
+    return {
+        success: true,
+        dialog_type: stored?.type || "unknown",
+        message: stored?.message || `Dialog ${action}ed (or no dialog was open)`,
+        accepted: action === "accept",
+    };
+}

package/dist/tools/drag.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Weavetab — tools/drag.ts
+ * browser_drag: mousedown on sourceNodeId, mousemove to targetNodeId, mouseup.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface DragOptions {
+    sourceNodeId: number;
+    targetNodeId: number;
+}
+export declare function browserDrag(session: CDP.Client, options: DragOptions, _config: Config): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=drag.d.ts.map

package/dist/tools/drag.js

@@ -0,0 +1,29 @@
+export async function browserDrag(session, options, _config) {
+    const { sourceNodeId, targetNodeId } = options;
+    if (!sourceNodeId || !targetNodeId) {
+        throw new Error("browser_drag requires sourceNodeId and targetNodeId");
+    }
+    const getCoords = async (nodeId) => {
+        const { model } = await session.DOM.getBoxModel({ backendNodeId: nodeId });
+        return {
+            x: (model.content[0] + model.content[2]) / 2,
+            y: (model.content[1] + model.content[5]) / 2
+        };
+    };
+    const src = await getCoords(sourceNodeId);
+    const tgt = await getCoords(targetNodeId);
+    // 1. Move to source
+    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: src.x, y: src.y });
+    // 2. Mouse down
+    await session.Input.dispatchMouseEvent({ type: "mousePressed", x: src.x, y: src.y, button: "left", clickCount: 1 });
+    // Small delay to let UI react (e.g. drag start handlers)
+    await new Promise(r => setTimeout(r, 100));
+    // 3. Move to target with button held
+    // In a real smooth drag, we'd interpolate this, but a direct move often works.
+    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: tgt.x, y: tgt.y, button: "left" });
+    await new Promise(r => setTimeout(r, 100));
+    // 4. Mouse up
+    await session.Input.dispatchMouseEvent({ type: "mouseReleased", x: tgt.x, y: tgt.y, button: "left", clickCount: 1 });
+    return { success: true };
+}
+//# sourceMappingURL=drag.js.map

package/dist/tools/emulation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Weavetab — tools/emulation.ts
+ * browser_emulate: Network, CPU, Geolocation, and Device emulation over CDP.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface EmulationOptions {
+    /** Network throttling profile or custom parameters */
+    network?: "offline" | "slow3g" | "fast3g" | "4g" | "online" | {
+        offline?: boolean;
+        latency?: number;
+        downloadThroughput?: number;
+        uploadThroughput?: number;
+    };
+    /** CPU slowdown multiplier (e.g. 2 for 2x slowdown, 4 for 4x slowdown, 1 to disable) */
+    cpuThrottlingRate?: number;
+    /** Override geolocation coordinates */
+    geolocation?: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    };
+    /** Override browser timezone (e.g. "America/New_York", "Europe/London") */
+    timezoneId?: string;
+    /** User Agent string override */
+    userAgent?: string;
+}
+export declare function browserEmulate(session: CDP.Client, options: EmulationOptions, _config: Config): Promise<{
+    success: boolean;
+    applied: string[];
+    error?: string;
+}>;

package/dist/tools/emulation.js

@@ -0,0 +1,69 @@
+/**
+ * Weavetab — tools/emulation.ts
+ * browser_emulate: Network, CPU, Geolocation, and Device emulation over CDP.
+ * Weavetab by fy2ne
+ */
+import { logAction } from "../audit/logger.js";
+const PRESET_NETWORK_PROFILES = {
+    offline: { offline: true, latency: 0, downloadThroughput: 0, uploadThroughput: 0 },
+    slow3g: { offline: false, latency: 400, downloadThroughput: 500 * 1024 / 8, uploadThroughput: 500 * 1024 / 8 },
+    fast3g: { offline: false, latency: 150, downloadThroughput: 1.6 * 1024 * 1024 / 8, uploadThroughput: 750 * 1024 / 8 },
+    "4g": { offline: false, latency: 50, downloadThroughput: 10 * 1024 * 1024 / 8, uploadThroughput: 5 * 1024 * 1024 / 8 },
+    online: { offline: false, latency: 0, downloadThroughput: -1, uploadThroughput: -1 },
+};
+export async function browserEmulate(session, options, _config) {
+    const applied = [];
+    try {
+        // 1. Network Throttling
+        if (options.network) {
+            await session.Network.enable();
+            let params = typeof options.network === "string"
+                ? PRESET_NETWORK_PROFILES[options.network]
+                : options.network;
+            if (params) {
+                await session.Network.emulateNetworkConditions({
+                    offline: params.offline ?? false,
+                    latency: params.latency ?? 0,
+                    downloadThroughput: params.downloadThroughput ?? -1,
+                    uploadThroughput: params.uploadThroughput ?? -1,
+                });
+                applied.push(`network: ${typeof options.network === "string" ? options.network : "custom"}`);
+            }
+        }
+        // 2. CPU Throttling
+        if (options.cpuThrottlingRate !== undefined) {
+            await session.Emulation.setCPUThrottlingRate({
+                rate: options.cpuThrottlingRate,
+            });
+            applied.push(`cpuThrottlingRate: ${options.cpuThrottlingRate}x`);
+        }
+        // 3. Geolocation Override
+        if (options.geolocation) {
+            await session.Emulation.setGeolocationOverride({
+                latitude: options.geolocation.latitude,
+                longitude: options.geolocation.longitude,
+                accuracy: options.geolocation.accuracy ?? 1,
+            });
+            applied.push(`geolocation: ${options.geolocation.latitude}, ${options.geolocation.longitude}`);
+        }
+        // 4. Timezone Override
+        if (options.timezoneId) {
+            await session.Emulation.setTimezoneOverride({
+                timezoneId: options.timezoneId,
+            });
+            applied.push(`timezoneId: ${options.timezoneId}`);
+        }
+        // 5. User Agent Override
+        if (options.userAgent) {
+            await session.Network.setUserAgentOverride({
+                userAgent: options.userAgent,
+            });
+            applied.push(`userAgent: ${options.userAgent}`);
+        }
+        logAction("browser_emulate", "emulation", applied.join(", "));
+        return { success: true, applied };
+    }
+    catch (err) {
+        return { success: false, applied, error: err?.message || String(err) };
+    }
+}

package/dist/tools/eval.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Weavetab — tools/eval.ts
+ * browser_eval: Run arbitrary sandboxed JS via Runtime.evaluate.
+ * Special command: expression "Weavetab.usage()" returns session metrics.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface EvalOptions {
+    expression: string;
+    timeout?: number;
+}
+export declare function browserEval(session: CDP.Client, options: EvalOptions, _config: Config): Promise<{
+    success: boolean;
+    result: any;
+    type: string;
+    error?: string;
+    url?: string;
+    title?: string;
+}>;

package/dist/tools/eval.js

@@ -0,0 +1,92 @@
+import { sendToExtension } from "../cdp/helpers.js";
+import { SessionSecretTracker } from "../security/secrets.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+export async function browserEval(session, options, _config) {
+    const { expression, timeout = 3000 } = options; // Reduced from 5000ms
+    if (!expression)
+        throw new Error("browser_eval requires an 'expression'");
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(_config));
+    if (active)
+        targetId = active.targetId;
+    sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: 'evaluating...' } }).catch(() => { });
+    // Always capture current page state so agent can detect navigation
+    let currentUrl = "";
+    let pageTitle = "";
+    try {
+        const { frameTree } = await session.Page.getFrameTree();
+        currentUrl = frameTree.frame.url;
+        try {
+            const titleRes = await session.Runtime.evaluate({ expression: 'document.title', returnByValue: true });
+            if (titleRes?.result?.value) {
+                pageTitle = titleRes.result.value;
+            }
+        }
+        catch { }
+        if (!pageTitle) {
+            const { result: t } = await session.Runtime.evaluate({ expression: 'document.title', returnByValue: true });
+            pageTitle = t?.value || "";
+        }
+    }
+    catch { /* non-fatal */ }
+    // Special intercept: Weavetab.usage() — returns in-process session metrics
+    if (expression.trim() === "Weavetab.usage()") {
+        const { getUsageStats } = await import("../sensors/pacing.js");
+        return { success: true, result: getUsageStats(), type: "object", url: currentUrl, title: pageTitle };
+    }
+    let evalExpr = expression.trim();
+    const isFunctionDecl = /^(?:async\s+)?function\b/.test(evalExpr) || /^(?:async\s*)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>\s*\{/.test(evalExpr);
+    const isAlreadyIIFE = /^\s*\((?:async\s+)?function/.test(evalExpr) || /^\s*\((?:async\s*)?\(/.test(evalExpr);
+    if (!isAlreadyIIFE && isFunctionDecl) {
+        evalExpr = `(${evalExpr})`;
+    }
+    let result, exceptionDetails;
+    const res1 = await session.Runtime.evaluate({
+        expression: evalExpr,
+        returnByValue: true,
+        awaitPromise: true,
+        timeout
+    });
+    result = res1.result;
+    exceptionDetails = res1.exceptionDetails;
+    if (exceptionDetails && exceptionDetails.exception?.description?.includes('SyntaxError: Illegal return statement')) {
+        evalExpr = `(async function(){\n${expression}\n})()`;
+        const res2 = await session.Runtime.evaluate({
+            expression: evalExpr,
+            returnByValue: true,
+            awaitPromise: true,
+            timeout
+        });
+        result = res2.result;
+        exceptionDetails = res2.exceptionDetails;
+    }
+    if (exceptionDetails) {
+        sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } }).catch(() => { });
+        return {
+            success: false,
+            result: null,
+            type: "error",
+            error: SessionSecretTracker.redact(targetId, exceptionDetails.exception?.description || exceptionDetails.text || ""),
+            url: currentUrl,
+            title: pageTitle,
+        };
+    }
+    sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } }).catch(() => { });
+    // When the expression returns undefined (e.g., el.click(), void functions, or IIFEs with no return),
+    // result.value is undefined and result.description is unhelpfully a type string.
+    // Return a clear message so agents know the eval succeeded — it just returned no value.
+    const rawResult = result.type === 'undefined'
+        ? "(expression ran successfully — returned undefined. To get a confirmation value, append ; 'ok' or return a string explicitly.)"
+        : result.value !== undefined ? result.value : result.description;
+    const redactedResult = typeof rawResult === 'string'
+        ? SessionSecretTracker.redact(targetId, rawResult)
+        : rawResult;
+    return {
+        success: true,
+        result: redactedResult,
+        type: result.type,
+        url: currentUrl,
+        title: pageTitle,
+    };
+}

package/dist/tools/fill.d.ts

@@ -0,0 +1,41 @@
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface FillField {
+    ref: string;
+    value: string;
+}
+/** A single cell write for Google Sheets / Canvas grid filling. */
+export interface GridCell {
+    /** Cell address in A1 notation, e.g. "A1", "B3", "C12". */
+    cell: string;
+    /** Value to type into the cell. */
+    value: string;
+}
+export interface FillOptions {
+    fields?: FillField[];
+    submit?: string;
+    scan_only?: boolean;
+    blast_mode?: boolean;
+    /** Grid-fill mode for Google Sheets and other canvas-rendered spreadsheets.
+     *  Provide cell addresses in A1 notation with their values.
+     *  The tool uses the Chrome Accessibility Tree to locate each cell. */
+    grid_data?: GridCell[];
+}
+export interface FillResult {
+    success: boolean;
+    total_fields: number;
+    succeeded: number;
+    failed: number;
+    submitted: boolean;
+    results: {
+        ref: string;
+        field_type: string;
+        success: boolean;
+        message: string;
+        value?: string;
+    }[];
+    execution_ms: number;
+    /** Concrete next step for the agent when fill fails */
+    suggestedNext?: string;
+}
+export declare function browserFill(session: CDP.Client, options: FillOptions, config: Config): Promise<FillResult>;