@weavetab/mcp 2.5.0-beta.5 → 2.5.1

package/dist/tools/office/parse.js

@@ -12,20 +12,20 @@ import mammoth from "mammoth";
 import * as xlsx from "xlsx";
 /** Fetch a URL inside the browser's context using fetch(), return base64-encoded bytes + MIME type. */
 async function cdpFetchAsBase64(session, url) {
-    const expression = `(async () => {
-    try {
-      const resp = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
-      if (!resp.ok) return JSON.stringify({ error: 'HTTP ' + resp.status + ' ' + resp.statusText });
-      const mime = resp.headers.get('content-type') || 'application/octet-stream';
-      const buf = await resp.arrayBuffer();
-      const bytes = new Uint8Array(buf);
-      let binary = '';
-      for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
-      const b64 = btoa(binary);
-      return JSON.stringify({ base64: b64, mimeType: mime });
-    } catch (e) {
-      return JSON.stringify({ error: e.message || String(e) });
-    }
+    const expression = `(async () => {
+    try {
+      const resp = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+      if (!resp.ok) return JSON.stringify({ error: 'HTTP ' + resp.status + ' ' + resp.statusText });
+      const mime = resp.headers.get('content-type') || 'application/octet-stream';
+      const buf = await resp.arrayBuffer();
+      const bytes = new Uint8Array(buf);
+      let binary = '';
+      for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+      const b64 = btoa(binary);
+      return JSON.stringify({ base64: b64, mimeType: mime });
+    } catch (e) {
+      return JSON.stringify({ error: e.message || String(e) });
+    }
   })()`;
     try {
         const { result } = await session.Runtime.evaluate({
@@ -63,6 +63,26 @@ function inferExtension(url, mimeType) {
         return ".csv";
     return ".bin";
 }
+const SUPPORTED_EXTENSIONS = [".csv", ".pdf", ".docx", ".xlsx", ".xls"];
+/** Detect the real container type from magic bytes. Returns null when unknown.
+ * ".html" is a sentinel meaning "got an HTML page instead of a document". */
+function sniffExtension(buffer, mimeType) {
+    if (buffer.length < 4)
+        return null;
+    if (buffer.subarray(0, 4).toString("latin1") === "%PDF")
+        return ".pdf";
+    if (buffer.readUInt32LE(0) === 0x04034b50) {
+        if (mimeType.includes("wordprocessingml") || mimeType.includes("msword"))
+            return ".docx";
+        return ".xlsx";
+    }
+    if (buffer[0] === 0x3c) {
+        const head = buffer.subarray(0, 500).toString("utf-8").toLowerCase();
+        if (head.includes("<html") || head.includes("<!doctype html"))
+            return ".html";
+    }
+    return null;
+}
 async function parseBuffer(buffer, ext, source, max_rows, max_chars) {
     try {
         if (ext === ".csv") {
@@ -143,8 +163,17 @@ export async function browserOfficeParse(session, options, config) {
             return { success: false, source: url, type: "unknown", error: `Fetch failed: ${fetchResult.error}` };
         }
         const { base64, mimeType } = fetchResult;
-        const ext = inferExtension(url, mimeType);
         const buffer = Buffer.from(base64, "base64");
+        const sniffed = sniffExtension(buffer, mimeType);
+        if (sniffed === ".html") {
+            return {
+                success: false,
+                source: url,
+                type: "html",
+                error: "URL returned an HTML page, not a document — the link may be behind a login or not a direct download",
+            };
+        }
+        const ext = sniffed ?? inferExtension(url, mimeType);
         logDebug(`[Office] URL fetch: ${url} → ${ext} (${buffer.length} bytes, mime=${mimeType})`);
         logAction("browser_office_parse", ext, `Parsing ${url} (${buffer.length} bytes)`);
         return parseBuffer(buffer, ext, url, max_rows, max_chars);
@@ -163,10 +192,25 @@ export async function browserOfficeParse(session, options, config) {
         if (!fs.existsSync(filePath)) {
             return { success: false, source: filename, type: "unknown", error: `File not found: ${filename}` };
         }
-        const ext = path.extname(filename).toLowerCase();
-        logAction("browser_office_parse", ext, `Parsing local file ${filename}`);
         const buffer = fs.readFileSync(filePath);
-        return parseBuffer(buffer, ext, filename, max_rows, max_chars);
+        const ext = path.extname(filename).toLowerCase();
+        let resolvedExt = ext;
+        if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+            const sniffed = sniffExtension(buffer, "");
+            if (sniffed === ".html") {
+                return {
+                    success: false,
+                    source: filename,
+                    type: "html",
+                    error: "File contains an HTML page, not a document — the download may be a login or error page",
+                };
+            }
+            if (sniffed) {
+                resolvedExt = sniffed;
+            }
+        }
+        logAction("browser_office_parse", resolvedExt, `Parsing local file ${filename}`);
+        return parseBuffer(buffer, resolvedExt, filename, max_rows, max_chars);
     }
     return { success: false, source: "", type: "unknown", error: "Unreachable" };
 }

package/dist/tools/pdf.d.ts

@@ -5,11 +5,20 @@
  */
 import CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
+export interface PdfMargins {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
 export interface PdfOptions {
     landscape?: boolean;
     scale?: number;
     pageRanges?: string;
     filename?: string;
+    /** Page margin in inches — a number (all sides) or per-side object.
+     * Default: 0.4 on every side. */
+    margin?: number | PdfMargins;
     /** If false, keeps the WeaveTab UI overlay visible in the PDF.
      * Default: true — overlay (cursor, thought bubble, HUD) is always hidden from PDFs. */
     hideOverlay?: boolean;

package/dist/tools/pdf.js

@@ -11,15 +11,18 @@ export async function browserPdf(session, options, config) {
     }
     await maskSecretFieldsForCapture(session);
     let data;
+    const margins = typeof options.margin === "number"
+        ? { top: options.margin, bottom: options.margin, left: options.margin, right: options.margin }
+        : (options.margin ?? {});
     try {
         const pdfRes = await session.Page.printToPDF({
             landscape: options.landscape ?? false,
             scale: options.scale ?? 1.0,
             pageRanges: options.pageRanges ?? "",
-            marginTop: 0.4, // 1cm ish
-            marginBottom: 0.4,
-            marginLeft: 0.4,
-            marginRight: 0.4,
+            marginTop: margins.top ?? 0.4, // 1cm ish
+            marginBottom: margins.bottom ?? 0.4,
+            marginLeft: margins.left ?? 0.4,
+            marginRight: margins.right ?? 0.4,
             printBackground: true
         });
         data = pdfRes.data;

package/dist/tools/performance.d.ts

@@ -1,12 +1,19 @@
 /**
  * Weavetab — tools/performance.ts
- * browser_performance: Retrieve page performance metrics (FCP, LCP, TTI).
+ * browser_performance: page performance metrics — Core Web Vitals, memory, navigation timing, resources, raw CDP counters.
  * Weavetab by fy2ne
  */
 import CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
-export declare function browserPerformance(session: CDP.Client, _config: Config): Promise<{
+export interface PerformanceOptions {
+    metrics?: ("vitals" | "memory" | "navigation" | "resources" | "raw")[];
+}
+export interface PerformanceResult {
     success: boolean;
-    metrics: Record<string, number>;
+    metrics?: Record<string, number>;
+    vitals?: Record<string, number>;
+    memory?: Record<string, number>;
+    navigation?: Record<string, any> | null;
     slowest_resources?: any[];
-}>;
+}
+export declare function browserPerformance(session: CDP.Client, _config: Config, options?: PerformanceOptions): Promise<PerformanceResult>;

package/dist/tools/performance.js

@@ -1,47 +1,99 @@
-export async function browserPerformance(session, _config) {
-    const { metrics: perfMetrics } = await session.Performance.getMetrics();
-    const parsed = {};
-    for (const m of perfMetrics) {
-        parsed[m.name] = m.value;
+const ALL_SECTIONS = [
+    "vitals",
+    "memory",
+    "navigation",
+    "resources",
+    "raw",
+];
+export async function browserPerformance(session, _config, options = {}) {
+    const sections = new Set(options.metrics && options.metrics.length > 0 ? options.metrics : ALL_SECTIONS);
+    const out = { success: true };
+    if (sections.has("raw")) {
+        const { metrics: perfMetrics } = await session.Performance.getMetrics();
+        const parsed = {};
+        for (const m of perfMetrics)
+            parsed[m.name] = m.value;
+        out.metrics = parsed;
     }
-    // Also grab FCP from the page itself
-    const { result } = await session.Runtime.evaluate({
-        expression: `
-      new Promise(resolve => {
-        const p = performance.getEntriesByType('paint');
-        const fcp = p.find(x => x.name === 'first-contentful-paint');
-        if (fcp) return resolve({ fcp: fcp.startTime });
-        new PerformanceObserver((list) => {
-          const entries = list.getEntries();
-          resolve({ fcp: entries[0].startTime });
-        }).observe({type: 'paint', buffered: true});
-        setTimeout(() => resolve({ fcp: -1 }), 1000);
-      })
-    `,
-        returnByValue: true,
-        awaitPromise: true
-    });
-    if (result.value && result.value.fcp !== -1) {
-        parsed.FirstContentfulPaint = result.value.fcp;
+    if (sections.has("vitals")) {
+        const { result } = await session.Runtime.evaluate({
+            expression: `(async () => {
+        const nav = performance.getEntriesByType('navigation')[0];
+        const paint = performance.getEntriesByType('paint');
+        const fcpEntry = paint.find(x => x.name === 'first-contentful-paint');
+        const vitals = {
+          fcp: fcpEntry ? fcpEntry.startTime : -1,
+          ttfb: nav ? Math.max(0, nav.responseStart - nav.requestStart) : -1,
+          domContentLoaded: nav ? nav.domContentLoadedEventEnd : -1,
+          load: nav ? nav.loadEventEnd : -1,
+          lcp: -1,
+          cls: -1,
+          inp: -1
+        };
+        const collect = (type, field, opts) => new Promise((resolve) => {
+          let value = field === 'cls' ? 0 : 0;
+          try {
+            const obs = new PerformanceObserver((list) => {
+              for (const e of list.getEntries()) {
+                if (field === 'lcp') value = Math.max(value, e.startTime || 0);
+                else if (field === 'cls') { if (!e.hadRecentInput) value += e.value || 0; }
+                else if (field === 'inp') value = Math.max(value, e.duration || 0);
+              }
+            });
+            obs.observe(opts);
+          } catch {}
+          setTimeout(() => resolve(value), 50);
+        });
+        vitals.lcp = await collect('largest-contentful-paint', 'lcp', { type: 'largest-contentful-paint', buffered: true });
+        vitals.cls = await collect('layout-shift', 'cls', { type: 'layout-shift', buffered: true });
+        vitals.inp = await collect('event', 'inp', { type: 'event', buffered: true, durationThreshold: 16 });
+        return JSON.stringify(vitals);
+      })()`,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        try {
+            out.vitals = JSON.parse(result.value);
+        }
+        catch {
+            out.vitals = {};
+        }
+    }
+    if (sections.has("memory")) {
+        const { result } = await session.Runtime.evaluate({
+            expression: `JSON.stringify(performance.memory ? { usedJSHeapSize: performance.memory.usedJSHeapSize, totalJSHeapSize: performance.memory.totalJSHeapSize, jsHeapSizeLimit: performance.memory.jsHeapSizeLimit } : {})`,
+            returnByValue: true,
+        });
+        try {
+            out.memory = JSON.parse(result.value);
+        }
+        catch {
+            out.memory = {};
+        }
     }
-    // Grab resource timings
-    const { result: resourceResult } = await session.Runtime.evaluate({
-        expression: `
-      JSON.stringify(performance.getEntriesByType('resource').map(r => ({
-        name: r.name,
-        duration: r.duration,
-        transferSize: r.transferSize,
-        initiatorType: r.initiatorType
-      })).sort((a, b) => b.duration - a.duration).slice(0, 10))
-    `,
-        returnByValue: true
-    });
-    let resources = [];
-    try {
-        if (resourceResult.value) {
-            resources = JSON.parse(resourceResult.value);
+    if (sections.has("navigation")) {
+        const { result } = await session.Runtime.evaluate({
+            expression: `JSON.stringify((function(){ var n = performance.getEntriesByType('navigation')[0]; if (!n) return null; return { type: n.type, redirectCount: n.redirectCount, domInteractive: n.domInteractive, domContentLoadedEventEnd: n.domContentLoadedEventEnd, loadEventEnd: n.loadEventEnd, transferSize: n.transferSize, encodedBodySize: n.encodedBodySize, decodedBodySize: n.decodedBodySize }; })())`,
+            returnByValue: true,
+        });
+        try {
+            out.navigation = JSON.parse(result.value);
+        }
+        catch {
+            out.navigation = null;
+        }
+    }
+    if (sections.has("resources")) {
+        const { result } = await session.Runtime.evaluate({
+            expression: `JSON.stringify(performance.getEntriesByType('resource').map(function(r){ return { name: r.name, duration: r.duration, transferSize: r.transferSize, initiatorType: r.initiatorType }; }).sort(function(a, b){ return b.duration - a.duration; }).slice(0, 10))`,
+            returnByValue: true,
+        });
+        try {
+            out.slowest_resources = JSON.parse(result.value);
+        }
+        catch {
+            out.slowest_resources = [];
         }
     }
-    catch { }
-    return { success: true, metrics: parsed, slowest_resources: resources };
+    return out;
 }

package/dist/tools/performance_test.d.ts

@@ -15,7 +15,7 @@
  *
  * AFTER (improved WeaveTab):
  * 1. browser_fill - fills both username and password with confirmation
- * 2. browser_click_and_wait - clicks submit and waits for response
+ * 2. browser_burst - clicks submit and waits for response
  *
  * Total: 2 tool calls
  *
@@ -51,7 +51,7 @@ export declare const navigationTaskMetrics: PerformanceMetrics;
  *    - Adaptive retry built into tools (max 2 internal retries)
  *    - Semantic response contract for all interaction tools
  *    - Loop prevention (tracks last 5 tool calls)
- *    - Consolidated tools (browser_click_and_wait) for common patterns
+ *    - Consolidated tools (browser_burst) for common patterns
  *
  * 4. IMPROVEMENT 4: Upgraded tool instructions
  *    - All tools now include "Prefer WeaveTab over Playwright" messaging

package/dist/tools/performance_test.js

@@ -4,21 +4,21 @@
 export const loginFormMetrics = {
     task: "Login form (username + password + submit)",
     beforeToolCalls: 7, // Average: map(1) + type(1) + type(1) + map(1) + click(1) + wait(1) + snapshot(1)
-    afterToolCalls: 2, // fill(1) + click_and_wait(1)
+    afterToolCalls: 2, // fill(1) + browser_burst(1)
     improvement: "71% reduction in tool calls",
     timeSaved: "~2-3 seconds saved from eliminated round-trips"
 };
 export const complexFormMetrics = {
     task: "Complex form (5 fields + submit)",
     beforeToolCalls: 12, // map(1) + type(5) + map(1) + click(1) + wait(1) + snapshot(1) + verify(2)
-    afterToolCalls: 2, // fill(1) + click_and_wait(1)
+    afterToolCalls: 2, // fill(1) + browser_burst(1)
     improvement: "83% reduction in tool calls",
     timeSaved: "~4-5 seconds saved from eliminated round-trips"
 };
 export const navigationTaskMetrics = {
     task: "Navigate to specific section (click link + wait)",
     beforeToolCalls: 4, // map(1) + click(1) + wait(1) + snapshot(1)
-    afterToolCalls: 1, // click_and_wait(1)
+    afterToolCalls: 1, // browser_burst(1)
     improvement: "75% reduction in tool calls",
     timeSaved: "~1-2 seconds saved from eliminated round-trips"
 };
@@ -42,7 +42,7 @@ export const navigationTaskMetrics = {
  *    - Adaptive retry built into tools (max 2 internal retries)
  *    - Semantic response contract for all interaction tools
  *    - Loop prevention (tracks last 5 tool calls)
- *    - Consolidated tools (browser_click_and_wait) for common patterns
+ *    - Consolidated tools (browser_burst) for common patterns
  *
  * 4. IMPROVEMENT 4: Upgraded tool instructions
  *    - All tools now include "Prefer WeaveTab over Playwright" messaging
@@ -59,70 +59,70 @@ export const navigationTaskMetrics = {
  * - Agent makes smarter tool choices and avoids redundant calls
  */
 export function generatePerformanceReport() {
-    return `
-# WeaveTab Performance Improvements Report
-
-## Summary
-Implemented three major improvements to reduce tool calls and improve reliability:
-1. Tool execution performance (confirmation + enriched responses)
-2. Fixed browser_fill (wt-id independence + full event sequence + adaptive retry)
-3. Smarter than Playwright (intent resolution + adaptive retry + semantic responses + loop prevention + consolidated tools)
-
-## Benchmark Results
-
-### Login Form Task
-**Task**: Fill username, fill password, click submit, wait for navigation
-- **Before**: 7 tool calls (map + type + type + map + click + wait + snapshot)
-- **After**: 2 tool calls (fill + click_and_wait)
-- **Improvement**: 71% reduction in tool calls, ~2-3 seconds saved
-
-### Complex Form Task
-**Task**: Fill 5 fields, click submit, wait for navigation
-- **Before**: 12 tool calls (map + type×5 + map + click + wait + snapshot + verify×2)
-- **After**: 2 tool calls (fill + click_and_wait)
-- **Improvement**: 83% reduction in tool calls, ~4-5 seconds saved
-
-### Navigation Task
-**Task**: Click link, wait for page load
-- **Before**: 4 tool calls (map + click + wait + snapshot)
-- **After**: 1 tool call (click_and_wait)
-- **Improvement**: 75% reduction in tool calls, ~1-2 seconds saved
-
-## Technical Details
-
-### browser_fill Improvements
-- **Before**: Depended on data-wt-id refs, no blur event, single strategy
-- **After**: 
-  - Works with selector/coordinates fallback
-  - Detects input type (text, textarea, select, checkbox, radio, contenteditable)
-  - Full event sequence: focus → input → change → blur
-  - Adaptive retry with 3 strategies (direct, nativeSetter, reactControlled)
-  - Returns: strategy, confirmed value, validation errors, element state
-
-### Response Contract
-All interaction tools now return:
-- confirmed: Whether effect was verified in DOM
-- strategy: What method was used
-- elementState: Element's full state after action
-- visibleFeedback: Any validation/toast text that appeared
-- suggestedNext: What the agent should likely do next
-
-### Loop Prevention
-- Tracks last 5 tool calls in rolling window
-- Detects 3 consecutive same-tool+target calls without state change
-- Returns STUCK signal with diagnosis instead of silent failure
-- Integrated into browser_click, browser_type, browser_fill
-
-### Consolidated Tools
-- **browser_click_and_wait**: Combines find + click + wait in one tool
-- Eliminates common pattern: browser_map → browser_click → browser_wait
-- Available in browser_burst macros
-
-## Expected Impact
-- 66-83% reduction in tool calls for common tasks
-- 2-5 seconds saved per form submission
-- Fewer loops and stuck situations
-- Better reliability with React/Vue controlled inputs
-- Agent can act more autonomously with fewer follow-up calls
+    return `
+# WeaveTab Performance Improvements Report
+
+## Summary
+Implemented three major improvements to reduce tool calls and improve reliability:
+1. Tool execution performance (confirmation + enriched responses)
+2. Fixed browser_fill (wt-id independence + full event sequence + adaptive retry)
+3. Smarter than Playwright (intent resolution + adaptive retry + semantic responses + loop prevention + consolidated tools)
+
+## Benchmark Results
+
+### Login Form Task
+**Task**: Fill username, fill password, click submit, wait for navigation
+- **Before**: 7 tool calls (map + type + type + map + click + wait + snapshot)
+- **After**: 2 tool calls (fill + browser_burst)
+- **Improvement**: 71% reduction in tool calls, ~2-3 seconds saved
+
+### Complex Form Task
+**Task**: Fill 5 fields, click submit, wait for navigation
+- **Before**: 12 tool calls (map + type×5 + map + click + wait + snapshot + verify×2)
+- **After**: 2 tool calls (fill + browser_burst)
+- **Improvement**: 83% reduction in tool calls, ~4-5 seconds saved
+
+### Navigation Task
+**Task**: Click link, wait for page load
+- **Before**: 4 tool calls (map + click + wait + snapshot)
+- **After**: 1 tool call (browser_burst)
+- **Improvement**: 75% reduction in tool calls, ~1-2 seconds saved
+
+## Technical Details
+
+### browser_fill Improvements
+- **Before**: Depended on data-wt-id refs, no blur event, single strategy
+- **After**: 
+  - Works with selector/coordinates fallback
+  - Detects input type (text, textarea, select, checkbox, radio, contenteditable)
+  - Full event sequence: focus → input → change → blur
+  - Adaptive retry with 3 strategies (direct, nativeSetter, reactControlled)
+  - Returns: strategy, confirmed value, validation errors, element state
+
+### Response Contract
+All interaction tools now return:
+- confirmed: Whether effect was verified in DOM
+- strategy: What method was used
+- elementState: Element's full state after action
+- visibleFeedback: Any validation/toast text that appeared
+- suggestedNext: What the agent should likely do next
+
+### Loop Prevention
+- Tracks last 5 tool calls in rolling window
+- Detects 3 consecutive same-tool+target calls without state change
+- Returns STUCK signal with diagnosis instead of silent failure
+- Integrated into browser_click, browser_type, browser_fill
+
+### Consolidated Tools
+- **browser_burst**: Combines find + click + wait in one tool
+- Eliminates common pattern: browser_map → browser_click → browser_wait
+- Available in browser_burst macros
+
+## Expected Impact
+- 66-83% reduction in tool calls for common tasks
+- 2-5 seconds saved per form submission
+- Fewer loops and stuck situations
+- Better reliability with React/Vue controlled inputs
+- Agent can act more autonomously with fewer follow-up calls
 `;
 }