@weavetab/mcp 2.5.0-beta.1 → 2.5.0-beta.4

package/dist/tools/burst.js

@@ -28,70 +28,88 @@ 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.
- */
+import { resetLoopCounter, getTrail } from "../intelligence/trail.js";
+function extractTarget(params) {
+    const target = {};
+    if (!params || typeof params !== "object")
+        return target;
+    if (params.ref !== undefined)
+        target.ref = params.ref;
+    if (params.id !== undefined)
+        target.id = params.id;
+    if (params.target !== undefined) {
+        if (typeof params.target === "string" && params.target.startsWith("w:"))
+            target.ref = params.target;
+        else
+            target.selector = params.target;
+    }
+    if (params.selector !== undefined)
+        target.selector = params.selector;
+    if (params.label !== undefined)
+        target.label = params.label;
+    if (params.x !== undefined)
+        target.x = params.x;
+    if (params.y !== undefined)
+        target.y = params.y;
+    return target;
+}
 function expandMacro(step) {
+    const args = step.args || {};
     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)");
-        }
+        const { text, pressEnter = true } = args;
+        const target = extractTarget(args);
         if (text === undefined) {
-            throw new Error("type_and_send macro failed: text argument is required");
+            throw new Error("type_and_send failed: text 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 typeArgs = { ...target, text, noRetry: true };
         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;
+        const { url } = 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 },
-        ];
+        const { wait_for, wait_value, wait_after, waitAfter } = args;
+        const target = extractTarget(args);
+        const clickArgs = {
+            ...target,
+            waitForNetwork: true,
+            waitAfter: wait_after ?? waitAfter ?? 500,
+        };
+        const steps = [{ tool: "browser_click", args: clickArgs }];
+        if (wait_for) {
+            steps.push({ tool: "browser_wait", args: { wait_for, value: wait_value } });
+        }
+        return steps;
     }
     if (step.tool === "scroll_and_read") {
-        const { direction, distance } = step.args;
+        const { direction, distance } = args;
         return [
             { tool: "browser_scroll", args: { direction, distance } },
             { tool: "browser_map", args: {} },
         ];
     }
     if (step.tool === "fill_form") {
-        const { fields, submit } = step.args;
+        const { fields, submit } = 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 (Array.isArray(fields)) {
+            for (const f of fields) {
+                if (f && typeof f === "object") {
+                    const target = extractTarget(f);
+                    steps.push({ tool: "browser_fill", args: { ...target, value: f.value } });
+                }
+            }
+        }
+        else if (fields && typeof fields === "object") {
+            for (const [key, value] of Object.entries(fields)) {
+                const target = key.startsWith("w:") ? { ref: key } : { id: key };
+                steps.push({ tool: "browser_fill", args: { ...target, value } });
             }
         }
         if (submit) {
@@ -100,18 +118,13 @@ function expandMacro(step) {
         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;
+        const { end_id, end_ref, end_x, end_y } = args;
+        const target = extractTarget(args);
+        const pointerArgs = { action: "drag_and_drop", ...target };
+        if (end_ref)
+            pointerArgs.end_ref = end_ref;
         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;
+            pointerArgs.end_id = end_id;
         if (end_x !== undefined)
             pointerArgs.end_x = end_x;
         if (end_y !== undefined)
@@ -119,53 +132,163 @@ function expandMacro(step) {
         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;
+        const { holdMs = 300 } = args;
+        const target = extractTarget(args);
         return [
-            { tool: "browser_pointer", args: pointerArgs },
+            { tool: "browser_pointer", args: { action: "hover", holdMs, ...target } },
             { tool: "browser_map", args: {} },
         ];
     }
     return [];
 }
+function normalizeRawSteps(raw) {
+    const norm = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const entry = item;
+        const tool = (entry.tool || entry.action);
+        if (!tool)
+            continue;
+        let stepArgs = {};
+        if (entry.args && typeof entry.args === "object" && !Array.isArray(entry.args)) {
+            stepArgs = { ...entry.args };
+        }
+        for (const [k, v] of Object.entries(entry)) {
+            if (k === "tool" || k === "args")
+                continue;
+            if (stepArgs[k] === undefined)
+                stepArgs[k] = v;
+        }
+        norm.push({ tool, args: stepArgs });
+    }
+    return norm;
+}
+function extractArgs(step) {
+    const s = step;
+    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;
+        }
+    }
+    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)) {
+            return val;
+        }
+    }
+    return {};
+}
+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_recording",
+    "type_and_send", "navigate_and_read", "click_and_wait",
+    "scroll_and_read", "fill_form", "drag_and_drop", "hover_and_read",
+]);
+export function compileTraceToMacro(steps) {
+    const macro = [];
+    let lastKey = "";
+    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);
+            const key = `${step.tool}:${JSON.stringify(args)}`;
+            if (key !== lastKey) {
+                macro.push({ tool: step.tool, args });
+                lastKey = key;
+            }
+        }
+    });
+    return macro;
+}
 export async function browserBurst(session, args, config) {
-    if (!args.steps || args.steps.length === 0) {
-        return { success: true, steps_completed: 0, results: [], aborted: false };
+    let rawSteps = args.steps || args.actions;
+    let compiledSteps;
+    if (args.compile_from_history) {
+        const trail = getTrail();
+        const limit = args.history_limit ?? 20;
+        const slice = limit > 0 ? trail.slice(-limit) : trail;
+        compiledSteps = compileTraceToMacro(slice);
+        if (args.dry_run) {
+            return {
+                success: true,
+                steps_completed: 0,
+                results: [],
+                aborted: false,
+                compiled_steps: compiledSteps,
+                message: `compiled ${compiledSteps.length} macro steps from history`,
+            };
+        }
+        if (!rawSteps || rawSteps.length === 0) {
+            rawSteps = compiledSteps;
+        }
+    }
+    const normalized = normalizeRawSteps(rawSteps || []);
+    if (normalized.length === 0) {
+        return {
+            success: true,
+            steps_completed: 0,
+            results: [],
+            aborted: false,
+            compiled_steps: compiledSteps,
+            message: args.compile_from_history ? "no actionable steps found in history" : "no steps provided",
+        };
     }
-    // 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) {
+    for (const step of normalized) {
         if (MACRO_TOOLS.has(step.tool)) {
             steps.push(...expandMacro(step));
         }
         else {
             steps.push({
                 tool: step.tool,
-                args: JSON.parse(JSON.stringify(step.args || {}))
+                args: JSON.parse(JSON.stringify(step.args || {})),
             });
         }
     }
-    const { batch } = args;
-    // Inject fast: true if batch mode is on, unless explicitly set to false
+    const { batch, stop_on_error } = args;
+    const stopOnError = stop_on_error !== false;
     if (batch) {
         for (const step of steps) {
-            if (step.args.fast === undefined) {
+            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'}...` } });
+    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];
@@ -180,7 +303,8 @@ export async function browserBurst(session, args, config) {
                     result = await weaveType(session, step.args, config);
                     break;
                 case "browser_go":
-                    result = await weaveNavigate(session, step.args.url, config);
+                case "browser_navigate":
+                    result = await weaveNavigate(session, step.args.url, config, undefined, false, false, args.app);
                     break;
                 case "browser_key":
                     result = await weaveKey(session, step.args, config);
@@ -192,7 +316,7 @@ export async function browserBurst(session, args, config) {
                     result = await browserWait(session, step.args, config);
                     break;
                 case "browser_map": {
-                    const mapTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId || "default";
+                    const mapTargetId = sessionRegistry.getActive(getConfigAgentId(config), args.app)?.targetId || "default";
                     result = await browserMap(session, step.args, mapTargetId, config);
                     break;
                 }
@@ -207,7 +331,7 @@ export async function browserBurst(session, args, config) {
                     break;
                 case "browser_console": {
                     let targetId = "default";
-                    const active = sessionRegistry.getActive(getConfigAgentId(config));
+                    const active = sessionRegistry.getActive(getConfigAgentId(config), args.app);
                     if (active)
                         targetId = active.targetId;
                     result = await browserConsole(session, step.args, config, targetId);
@@ -219,9 +343,6 @@ export async function browserBurst(session, args, config) {
                 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;
@@ -307,38 +428,74 @@ export async function browserBurst(session, args, config) {
                 results.push({ step: i + 1, tool: step.tool, success: false, error: stepError });
                 stepsCompleted++;
                 logAction("browser_burst", `step_${i + 1}`, `error: ${stepError}`);
+                if (stopOnError) {
+                    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } });
+                    return {
+                        success: false,
+                        steps_completed: stepsCompleted,
+                        results,
+                        aborted: true,
+                        abort_reason: `halted on step ${i + 1} (${step.tool}): ${stepError}`,
+                        compiled_steps: compiledSteps,
+                    };
+                }
                 continue;
             }
             const resultObj = result && typeof result === "object" ? result : {};
             const isError = resultObj.success === false;
+            const errDetail = resultObj.message || resultObj.stuck_hint || undefined;
             results.push({
                 step: i + 1,
                 tool: step.tool,
                 success: !isError,
                 result: isError ? undefined : result,
-                error: isError ? resultObj.message || resultObj.stuck_hint || undefined : undefined,
+                error: isError ? errDetail : undefined,
             });
             stepsCompleted++;
+            if (isError && stopOnError) {
+                logAction("browser_burst", `step_${i + 1}`, `halted on error: ${errDetail}`);
+                await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } });
+                return {
+                    success: false,
+                    steps_completed: stepsCompleted,
+                    results,
+                    aborted: true,
+                    abort_reason: `halted on step ${i + 1} (${step.tool}): ${errDetail ?? "action failed"}`,
+                    compiled_steps: compiledSteps,
+                };
+            }
         }
         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)}` });
+            const errMsg = err?.message ?? String(err);
+            logAction("browser_burst", `step_${i + 1}`, `exception: ${errMsg}`);
+            results.push({ step: i + 1, tool: step.tool, success: false, error: `Exception: ${errMsg}` });
             stepsCompleted++;
+            if (stopOnError) {
+                await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } });
+                return {
+                    success: false,
+                    steps_completed: stepsCompleted,
+                    results,
+                    aborted: true,
+                    abort_reason: `exception on step ${i + 1} (${step.tool}): ${errMsg}`,
+                    compiled_steps: compiledSteps,
+                };
+            }
         }
         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);
+    const allPassed = results.length > 0 && results.every(r => r.success);
     return {
-        success: anySuccess,
+        success: allPassed,
         steps_completed: stepsCompleted,
         results,
         aborted: false,
+        compiled_steps: compiledSteps,
     };
 }

package/dist/tools/checkpoint.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Weavetab — tools/checkpoint.ts
+ * browser_checkpoint: Session time-travel and rollback.
+ *
+ * Captures and restores named checkpoints of browser state:
+ *   - Cookies (HttpOnly and Secure via CDP Network)
+ *   - LocalStorage & SessionStorage
+ *   - URL, page title, and viewport scroll position
+ *   - Optional lightweight DOM snapshot
+ *
+ * Saves tokens and time when trial-and-error automation branches fail.
+ *
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface CheckpointData {
+    name: string;
+    url: string;
+    title: string;
+    timestamp: string;
+    cookies: any[];
+    localStorage: Record<string, string>;
+    sessionStorage: Record<string, string>;
+    scroll?: {
+        x: number;
+        y: number;
+    };
+    domSnapshot?: string;
+}
+export interface CheckpointArgs {
+    action: "save" | "restore" | "list" | "delete";
+    name?: string;
+    includeDom?: boolean;
+}
+export declare function getCheckpointsForTarget(targetId: string): Map<string, CheckpointData>;
+export declare function clearAllCheckpoints(): void;
+export declare function browserCheckpoint(session: CDP.Client, args: CheckpointArgs, config: Config): Promise<any>;