@weavetab/mcp 2.5.0-beta.0

package/dist/tools/select.js

@@ -0,0 +1,217 @@
+import { recordAction } from "../intelligence/trail.js";
+import { confirmChange } from "../cdp/confirm.js";
+import { getCachedActionMap, cacheActionMap } from "../state/cache.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { buildActionMap, safeSelector } from "../cdp/walker.js";
+async function getSelector(session, options, config) {
+    if (options.selector)
+        return options.selector;
+    if (options.ref || options.id) {
+        const ref = (options.ref || options.id);
+        let targetId = "default";
+        const active = sessionRegistry.getActive(getConfigAgentId(config));
+        if (active)
+            targetId = active.targetId;
+        const { frameTree } = await session.Page.getFrameTree();
+        const url = frameTree.frame.url;
+        let map = getCachedActionMap(targetId, url);
+        if (!map) {
+            map = await buildActionMap(session, { lite: true }, targetId);
+            cacheActionMap(targetId, map);
+        }
+        const element = map.elements.find(el => el.id === ref || el.id.endsWith(ref.startsWith("w:") ? ref.slice(2) : ref));
+        if (element) {
+            const sel = safeSelector(element);
+            if (sel)
+                return sel;
+        }
+        throw new Error(`Could not resolve element for ref/id: ${ref}`);
+    }
+    if (options.nodeId) {
+        const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [options.nodeId] });
+        if (!nodeIds[0])
+            throw new Error("Node not found");
+        const { object } = await session.DOM.resolveNode({ nodeId: nodeIds[0] });
+        if (!object?.objectId)
+            throw new Error("Could not resolve node");
+        const { result } = await session.Runtime.callFunctionOn({
+            objectId: object.objectId,
+            functionDeclaration: `function() {
+        if (this.id) return '#' + CSS.escape(this.id);
+        if (this.name) return 'select[name="' + CSS.escape(this.name) + '"]';
+        var idx = 0, el = this;
+        while (el.previousElementSibling) { idx++; el = el.previousElementSibling; }
+        var parent = this.parentElement;
+        if (!parent) return 'select:last-of-type';
+        var tag = this.tagName.toLowerCase();
+        return tag + ':nth-child(' + (idx + 1) + ')';
+      }()`,
+            returnByValue: true
+        });
+        return result.value;
+    }
+    throw new Error("browser_select requires either selector, nodeId, ref, or id");
+}
+function escapeSelector(sel) {
+    return JSON.stringify(sel);
+}
+export async function browserSelect(session, options, _config) {
+    if (!options.selector && !options.nodeId && !options.ref && !options.id) {
+        throw new Error("browser_select requires either selector, nodeId, ref, or id");
+    }
+    const selector = await getSelector(session, options, _config);
+    const value = options.value;
+    const getSelectState = async () => {
+        const { result } = await session.Runtime.evaluate({
+            expression: `(function() {
+        try {
+          var el = document.querySelector(${escapeSelector(selector)});
+          if (!el) return JSON.stringify({ exists: "false" });
+          if (el.tagName === "SELECT") {
+            var idx = el.selectedIndex;
+            var opt = idx >= 0 ? el.options[idx] : null;
+            return JSON.stringify({
+              exists: "true",
+              isNative: "true",
+              selectedIndex: String(idx),
+              value: el.value,
+              selectedText: opt ? opt.text : ""
+            });
+          }
+          // Custom UI Dropdown / Combobox / Popover
+          var text = (el.innerText || el.textContent || "").trim();
+          var val = el.getAttribute("data-value") || el.getAttribute("aria-valuenow") || text;
+          return JSON.stringify({
+            exists: "true",
+            isNative: "false",
+            value: val,
+            selectedText: text
+          });
+        } catch(e) {
+          return JSON.stringify({ exists: "false", error: e.message });
+        }
+      })()`,
+            returnByValue: true
+        });
+        return JSON.parse(result?.value || '{}');
+    };
+    const action = async () => {
+        const { result } = await session.Runtime.evaluate({
+            expression: `(function(selector, value) {
+        try {
+          const el = document.querySelector(selector);
+          if (!el) return 'Element not found';
+
+          // ── NATIVE <select> ELEMENT ──────────────────────────────────────
+          if (el.tagName === 'SELECT') {
+            let foundIndex = -1;
+            for (let i = 0; i < el.options.length; i++) {
+              const opt = el.options[i];
+              if (opt.value === value || opt.text === value || opt.text.trim() === value.trim()) {
+                foundIndex = i;
+                break;
+              }
+            }
+            if (foundIndex === -1) return 'Option not found in <select>: ' + value;
+
+            el.selectedIndex = foundIndex;
+
+            const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLSelectElement.prototype, 'value')?.set;
+            if (nativeSetter) nativeSetter.call(el, el.options[foundIndex].value);
+
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+            el.options[foundIndex].dispatchEvent(new MouseEvent('click', { bubbles: true }));
+
+            return 'selected:' + el.selectedIndex;
+          }
+
+          // ── CUSTOM ARIA / REACT / RADIX / SHADCN DROPDOWN ────────────────
+          // 1. Open popover if closed
+          const isExpanded = el.getAttribute('aria-expanded') === 'true';
+          if (!isExpanded) {
+            el.click();
+            el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+            el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+          }
+
+          // 2. Scan options in open popover / listbox
+          const targetText = value.toLowerCase().trim();
+          const optionSelectors = [
+            '[role="option"]',
+            '[role="menuitem"]',
+            '[role="treeitem"]',
+            '[data-radix-collection-item]',
+            'li',
+            '.option',
+            '.select-option',
+            '[data-value]'
+          ];
+
+          let candidates = Array.from(document.querySelectorAll(optionSelectors.join(',')));
+          // Fallback to all visible clickable items inside active popovers/listboxes
+          if (candidates.length === 0) {
+            const containers = document.querySelectorAll('[role="listbox"], [role="menu"], [data-radix-popper-content-wrapper], .select-popover, .dropdown-menu');
+            containers.forEach(c => {
+              candidates.push(...Array.from(c.querySelectorAll('*')));
+            });
+          }
+
+          let matchedEl = null;
+          for (const cand of candidates) {
+            const text = (cand.innerText || cand.textContent || '').toLowerCase().trim();
+            const valAttr = (cand.getAttribute('data-value') || cand.getAttribute('value') || '').toLowerCase().trim();
+            if (text === targetText || valAttr === targetText || text.includes(targetText)) {
+              matchedEl = cand;
+              break;
+            }
+          }
+
+          if (!matchedEl) {
+            return 'Custom option not found: ' + value;
+          }
+
+          matchedEl.click();
+          matchedEl.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+          matchedEl.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+
+          return 'selected:custom';
+        } catch (e) {
+          return e.message || 'Unknown error';
+        }
+      })(${escapeSelector(selector)}, ${escapeSelector(value)})`,
+            returnByValue: true
+        });
+        const resultVal = result?.value;
+        if (!resultVal || (!resultVal.startsWith('selected:') && resultVal !== 'success')) {
+            throw new Error(resultVal || 'Selection failed');
+        }
+    };
+    const beforeState = await getSelectState();
+    if (beforeState.exists === "false") {
+        throw new Error("Element not found");
+    }
+    const confirm = await confirmChange(session, getSelectState, action, {
+        verifyPasses: [16, 50, 200, 400],
+    });
+    if (confirm.applied) {
+        recordAction({
+            timestamp: new Date().toISOString(),
+            tool: 'browser_select',
+            input: { ref: selector, value },
+            result: { success: true, stuck: false },
+        });
+        return { success: true, message: `Selected value "${value}" on ${beforeState.isNative === "true" ? "native <select>" : "custom UI dropdown"} (${confirm.attempts} attempts, settled ${confirm.settleMs}ms)` };
+    }
+    recordAction({
+        timestamp: new Date().toISOString(),
+        tool: 'browser_select',
+        input: { ref: selector, value },
+        result: { success: false, stuck: true },
+    });
+    return {
+        success: false,
+        message: `Selection did not take effect. Before: value="${beforeState.value}". After: value="${confirm.after.value}".`
+    };
+}

package/dist/tools/snapshot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Weavetab — tools/snapshot.ts
+ * browser_snapshot: Create and restore MHTML snapshots of the DOM state.
+ *
+ * Secret containment: before capture, all elements marked data-wt-secret have
+ * their value blanked in the live DOM (then restored after capture). This prevents
+ * typed credential values from appearing in the MHTML archive.
+ *
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface SnapshotOptions {
+    action: "capture" | "restore";
+    /** Preferred parameter name. */
+    filename?: string;
+    /** Accepted alias for filename (sent by the MCP schema). */
+    filePath?: string;
+    /** If false, keeps the WeaveTab UI overlay visible in the MHTML snapshot.
+     * Default: true — overlay (cursor, thought bubble, HUD) is always hidden from snapshots. */
+    hideOverlay?: boolean;
+}
+export declare function browserSnapshot(session: CDP.Client, options: SnapshotOptions, config: Config): Promise<{
+    success: boolean;
+    message: string;
+    warning?: string;
+}>;

package/dist/tools/snapshot.js

@@ -0,0 +1,99 @@
+import fs from "fs/promises";
+import path from "path";
+import { getOutputDir, getConfigAgentId } from "../config/loader.js";
+import { hideWeaveTabOverlay, restoreWeaveTabOverlay } from "../cdp/helpers.js";
+import { clearTabCache } from "../state/cache.js";
+import { clearSnapshot } from "../state/delta.js";
+import { sessionRegistry } from "../state/session.js";
+export async function browserSnapshot(session, options, config) {
+    const { action } = options;
+    // Accept both `filename` (original) and `filePath` (MCP schema alias)
+    let { filename } = options;
+    if (!filename)
+        filename = options.filePath;
+    if (!filename || !filename.trim()) {
+        throw new Error("browser_snapshot requires a filename.");
+    }
+    // Strip any absolute path provided by the caller — always save in the managed snapshot dir
+    filename = path.basename(filename);
+    if (!filename.endsWith(".mhtml"))
+        filename += ".mhtml";
+    const snapshotDir = getOutputDir("snapshots", config);
+    const filePath = path.join(snapshotDir, filename);
+    if (action === "capture") {
+        // Always hide overlay before capture (default true); set hideOverlay: false to skip.
+        const shouldHide = options.hideOverlay !== false;
+        if (shouldHide) {
+            await hideWeaveTabOverlay(session);
+        }
+        // ── Blank secret field values before capture ──────────────────────────
+        // Prevents credential values from being embedded in the MHTML archive.
+        // data-wt-secret is set by browser_type_secret at injection time.
+        await session.Runtime.evaluate({
+            expression: `(function() {
+        var els = document.querySelectorAll('[data-wt-secret], input[type="password"]');
+        for (var i = 0; i < els.length; i++) {
+          var el = els[i];
+          el.__wt_snap_backup = el.value;
+          try { el.value = ''; } catch(e) {}
+          if (el.isContentEditable) {
+            el.__wt_snap_text_backup = el.textContent;
+            try { el.textContent = ''; } catch(e) {}
+          }
+        }
+      })()`,
+            returnByValue: false,
+        }).catch(() => { });
+        let snapshotData;
+        try {
+            const res = await session.Page.captureSnapshot({ format: "mhtml" });
+            snapshotData = res.data;
+        }
+        finally {
+            // ── Restore secret field values after capture (always runs) ──────────
+            if (shouldHide) {
+                await restoreWeaveTabOverlay(session);
+            }
+            await session.Runtime.evaluate({
+                expression: `(function() {
+          var els = document.querySelectorAll('[data-wt-secret], input[type="password"]');
+          for (var i = 0; i < els.length; i++) {
+            var el = els[i];
+            if (el.__wt_snap_backup !== undefined) {
+              try { el.value = el.__wt_snap_backup; } catch(e) {}
+              delete el.__wt_snap_backup;
+            }
+            if (el.__wt_snap_text_backup !== undefined) {
+              try { el.textContent = el.__wt_snap_text_backup; } catch(e) {}
+              delete el.__wt_snap_text_backup;
+            }
+          }
+        })()`,
+                returnByValue: false,
+            }).catch(() => { });
+        }
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, snapshotData, "utf8");
+        return { success: true, message: `Snapshot saved to ${filePath}` };
+    }
+    else if (action === "restore") {
+        // Navigate to the local MHTML file
+        // Note: Chrome must have access to the file path.
+        const fileUrl = `file:///${filePath.replace(/\\/g, '/')}`;
+        await session.Page.navigate({ url: fileUrl });
+        // Invalidate cached ref IDs after restore: the entire DOM is replaced, making
+        // all cached w:NN ref IDs stale. Clearing both the action-map cache and the
+        // delta snapshot forces the next browser_map / browser_inspect call to rebuild
+        // a fresh map with valid refs for the restored page.
+        const active = sessionRegistry.getActive(getConfigAgentId(config));
+        const targetId = active?.targetId ?? "default";
+        clearTabCache(targetId);
+        clearSnapshot(targetId);
+        return {
+            success: true,
+            message: `Restored snapshot from ${filePath}`,
+            warning: "Ref cache cleared — call browser_map to get fresh w:NN IDs for this restored page before using any ref-based tools.",
+        };
+    }
+    throw new Error("Unknown action");
+}

package/dist/tools/storage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Weavetab — tools/storage.ts
+ * browser_storage: read/write localStorage and sessionStorage via Runtime.evaluate.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface StorageOptions {
+    scope: "local" | "session";
+    action: "get" | "set" | "clear";
+    key?: string;
+    value?: string;
+}
+export declare function browserStorage(session: CDP.Client, options: StorageOptions, _config: Config): Promise<{
+    success: boolean;
+    result?: string | null;
+    message?: string;
+}>;

package/dist/tools/storage.js

@@ -0,0 +1,29 @@
+export async function browserStorage(session, options, _config) {
+    const { scope, action, key, value } = options;
+    if (action === "get") {
+        if (!key)
+            throw new Error("browser_storage get requires a 'key'");
+        const { result } = await session.Runtime.evaluate({
+            // Use JSON.stringify to safely embed the key — no raw string interpolation
+            expression: `(function(k){ return ${scope}Storage.getItem(k); })(${JSON.stringify(key)})`,
+            returnByValue: true
+        });
+        return { success: true, result: result.value };
+    }
+    else if (action === "set") {
+        if (!key || value === undefined)
+            throw new Error("browser_storage set requires 'key' and 'value'");
+        await session.Runtime.evaluate({
+            // Use JSON.stringify to safely embed key and value — no raw string interpolation
+            expression: `(function(k,v){ ${scope}Storage.setItem(k,v); })(${JSON.stringify(key)}, ${JSON.stringify(value ?? "")})`
+        });
+        return { success: true, message: `Set ${scope}Storage key ${key}` };
+    }
+    else if (action === "clear") {
+        await session.Runtime.evaluate({
+            expression: `${scope}Storage.clear()`
+        });
+        return { success: true, message: `Cleared ${scope}Storage` };
+    }
+    throw new Error(`Unknown action: ${action}`);
+}

package/dist/tools/tabs.d.ts

@@ -0,0 +1,77 @@
+import type { Config } from "../config/loader.js";
+export declare function recordTabActivity(targetId: string): void;
+export declare function lockTab(targetId: string): void;
+export declare function unlockTab(targetId: string): void;
+export declare function evaluateTabSemantics(targetId: string): Promise<void>;
+export interface TabInfo {
+    id: string;
+    title: string;
+    url: string;
+    status: "active" | "idle" | "loading" | "locked" | "alive" | "dead" | "unreachable";
+    health: "alive" | "dead" | "unreachable";
+    score: number;
+}
+export declare function WeavetabOpen(url: string, config: Config, reuse?: boolean): Promise<{
+    success: true;
+    tabId: string;
+    url: string;
+    reused?: boolean;
+}>;
+export declare function WeavetabSwitch(tabId: string, config: Config): Promise<{
+    success: true;
+    tab_id: string;
+    title: string;
+    url: string;
+    contextSwitchCostMs: number;
+}>;
+export declare function WeavetabList(config: Config): Promise<{
+    tabs: TabInfo[];
+}>;
+export declare function WeavetabClose(tabId: string, config: Config, force?: boolean): Promise<{
+    success: true;
+    tab_id: string;
+}>;
+/**
+ * Batch close multiple tabs at once — saves multiple round-trips.
+ */
+export declare function WeavetabCloseBatch(tabIds: string[], config: Config, force?: boolean): Promise<{
+    success: true;
+    closed: string[];
+    skipped: string[];
+}>;
+/**
+ * Consolidate: deduplicate tabs by URL, close duplicates.
+ */
+export declare function WeavetabConsolidate(config: Config): Promise<{
+    success: true;
+    tabs_before: number;
+    tabs_after: number;
+    closed_duplicates: number;
+}>;
+/**
+ * Heal: check all tabs for crashed state and reload them.
+ */
+export declare function WeavetabHeal(config: Config): Promise<{
+    success: true;
+    healed: number;
+    tabs_checked: number;
+    health_summary: Record<string, string>;
+}>;
+export interface WindowInfo {
+    windowId: number;
+    state: string;
+    bounds: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    focused: boolean;
+}
+export declare function weaveWindowList(config: Config): Promise<{
+    windows: WindowInfo[];
+}>;
+export declare function weaveFocusWindow(windowId: number, config: Config): Promise<{
+    success: true;
+    windowId: number;
+}>;