@weavetab/mcp 2.5.0-beta.0

package/dist/tools/tabs.js

@@ -0,0 +1,342 @@
+import { logDebug } from "../audit/logger.js";
+import CDP from "chrome-remote-interface";
+import { logAction } from "../audit/logger.js";
+import { connectToTab, getPort, getTabList } from "../cdp/connector.js";
+import { sessionRegistry } from "../state/session.js";
+import { clearTabCache } from "../state/cache.js";
+import { readLock } from "../cdp/lock.js";
+import { resetLoopCounter } from "../intelligence/trail.js";
+import { getConfigAgentId, getConfigMaxTabs } from "../config/loader.js";
+/** Resolve the active CDP port — live > lock file */
+function resolvePort(_config) {
+    const port = getPort() || readLock()?.port;
+    if (!port)
+        throw new Error("[!] No active browser session. Run browser_go first.");
+    return port;
+}
+const IDLE_THRESHOLD_MS = 30_000;
+const lastActivityMs = new Map();
+// Phase 3: Semantic Tab Registry
+const semanticScores = new Map();
+const lockedTabIds = new Set();
+export function recordTabActivity(targetId) {
+    lastActivityMs.set(targetId, Date.now());
+}
+export function lockTab(targetId) {
+    lockedTabIds.add(targetId);
+    logAction("browser_tabs", targetId, `Locked tab to prevent auto-close`);
+}
+export function unlockTab(targetId) {
+    lockedTabIds.delete(targetId);
+}
+// Score a tab based on title/url to determine importance (1-100)
+// Higher score = More critical = Less likely to be closed
+function calculateSemanticScore(url, title) {
+    let score = 10; // base score
+    const t = (title + " " + url).toLowerCase();
+    if (t.includes("login") || t.includes("sign in") || t.includes("auth"))
+        score += 60;
+    if (t.includes("checkout") || t.includes("payment") || t.includes("cart"))
+        score += 70;
+    if (t.includes("dashboard") || t.includes("admin"))
+        score += 40;
+    if (t.includes("mail") || t.includes("inbox"))
+        score += 30;
+    return Math.min(score, 100);
+}
+export async function evaluateTabSemantics(targetId) {
+    try {
+        const client = await connectToTab(targetId);
+        const result = await client.session.Runtime.evaluate({
+            expression: `JSON.stringify({ title: document.title, url: location.href })`,
+            returnByValue: true
+        });
+        if (result && result.result.value) {
+            const data = JSON.parse(result.result.value);
+            const score = calculateSemanticScore(data.url, data.title);
+            semanticScores.set(targetId, score);
+            // Auto-lock highly critical tabs
+            if (score >= 70)
+                lockTab(targetId);
+        }
+    }
+    catch (e) {
+        // Silently fail if page isn't ready
+    }
+}
+function isIdleTab(targetId, activeTargetId) {
+    if (targetId === activeTargetId)
+        return false;
+    if (lockedTabIds.has(targetId))
+        return false;
+    const lastSeen = lastActivityMs.get(targetId) ?? 0;
+    return Date.now() - lastSeen > IDLE_THRESHOLD_MS;
+}
+// ─── Auto-close oldest, lowest-score idle tab ────────────────────────────────
+async function enforceMaxTabs(config) {
+    const port = resolvePort(config);
+    const pages = await getTabList(getConfigAgentId(config));
+    if (pages.length < getConfigMaxTabs(config))
+        return;
+    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+    // Find oldest idle tab, weighted by semantic score
+    const idleCandidates = pages
+        .filter((t) => isIdleTab(t.id, activeTargetId))
+        .sort((a, b) => {
+        const scoreA = semanticScores.get(a.id) ?? 10;
+        const scoreB = semanticScores.get(b.id) ?? 10;
+        if (scoreA !== scoreB)
+            return scoreA - scoreB; // Lower score closed first
+        return (lastActivityMs.get(a.id) ?? 0) - (lastActivityMs.get(b.id) ?? 0); // Older closed first
+    });
+    if (idleCandidates.length === 0) {
+        logDebug("[Weavetab] maxTabs reached but no closable idle tab found.");
+        return;
+    }
+    const victim = idleCandidates[0];
+    logDebug(`[Weavetab] maxTabs (${getConfigMaxTabs(config)}) reached — closing lowest-score tab: ${victim.id} (${victim.title})`);
+    await CDP.Close({ host: "127.0.0.1", port, id: victim.id });
+    clearTabCache(victim.id);
+    sessionRegistry.unregister(victim.id);
+    lastActivityMs.delete(victim.id);
+    semanticScores.delete(victim.id);
+    lockedTabIds.delete(victim.id);
+    logAction("browser_tabs", victim.id, `auto-closed idle tab: ${victim.title}`);
+}
+// ─── Tools ────────────────────────────────────────────────────────────────────
+export async function WeavetabOpen(url, config, reuse = true) {
+    const port = resolvePort(config);
+    // Tab reuse: if same URL is already open, focus it instead of duplicating
+    if (reuse && url) {
+        try {
+            const targets = await getTabList(getConfigAgentId(config));
+            const existing = targets.find((t) => t.url === url);
+            if (existing) {
+                const client = await connectToTab(existing.id);
+                await client.session.Target.activateTarget({ targetId: existing.id });
+                sessionRegistry.setActive(existing.id, getConfigAgentId(config));
+                recordTabActivity(existing.id);
+                logAction("browser_tabs", url, `reused existing tab ${existing.id}`);
+                return { success: true, tabId: existing.id, url, reused: true };
+            }
+        }
+        catch { /* fall through to open new */ }
+    }
+    await enforceMaxTabs(config);
+    const bctxId = sessionRegistry.getBrowserContextIdForAgent(getConfigAgentId(config));
+    const metaSession = await CDP({ host: "127.0.0.1", port });
+    const { targetId } = await metaSession.Target.createTarget({ url, browserContextId: bctxId });
+    await metaSession.close();
+    recordTabActivity(targetId);
+    await connectToTab(targetId, port, getConfigAgentId(config), bctxId);
+    await evaluateTabSemantics(targetId);
+    logAction("browser_tabs", url, `opened ${targetId}`);
+    return { success: true, tabId: targetId, url };
+}
+export async function WeavetabSwitch(tabId, config) {
+    const client = await connectToTab(tabId);
+    const startSwitch = Date.now();
+    await client.session.Target.activateTarget({ targetId: tabId });
+    sessionRegistry.setActive(tabId, getConfigAgentId(config));
+    recordTabActivity(tabId);
+    const { frameTree } = await client.session.Page.getFrameTree();
+    let title = tabId;
+    try {
+        const titleRes = await client.session.Runtime.evaluate({ expression: 'document.title', returnByValue: true });
+        if (titleRes?.result?.value) {
+            title = titleRes.result.value;
+        }
+    }
+    catch { }
+    const url = frameTree.frame.url;
+    const cost = Date.now() - startSwitch;
+    logAction("browser_tabs", tabId, `switched to ${title} (cost: ${cost}ms)`);
+    resetLoopCounter("tab_switch");
+    return { success: true, tab_id: tabId, title, url, contextSwitchCostMs: cost };
+}
+export async function WeavetabList(config) {
+    const targets = await getTabList(getConfigAgentId(config));
+    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+    const tabs = targets
+        .map((t) => ({
+        id: t.id,
+        title: t.title,
+        url: t.url,
+        score: semanticScores.get(t.id) ?? 10,
+        health: sessionRegistry.getHealth(t.id),
+        status: t.id === activeTargetId
+            ? "active"
+            : lockedTabIds.has(t.id)
+                ? "locked"
+                : isIdleTab(t.id, activeTargetId)
+                    ? "idle"
+                    : "loading",
+    }));
+    return { tabs };
+}
+export async function WeavetabClose(tabId, config, force = false) {
+    const score = semanticScores.get(tabId) ?? 10;
+    if (score >= 70 && !force) {
+        throw new Error(`[!] Tab Armor block: This tab is semantically protected (score: ${score}). It likely contains a login, checkout, or critical work. Do not close it! If the user explicitly requested this closure, pass force: true.`);
+    }
+    const port = resolvePort(config);
+    await CDP.Close({ host: "127.0.0.1", port, id: tabId });
+    clearTabCache(tabId);
+    sessionRegistry.unregister(tabId);
+    lastActivityMs.delete(tabId);
+    semanticScores.delete(tabId);
+    lockedTabIds.delete(tabId);
+    logAction("browser_tabs", tabId, "closed");
+    return { success: true, tab_id: tabId };
+}
+/**
+ * Batch close multiple tabs at once — saves multiple round-trips.
+ */
+export async function WeavetabCloseBatch(tabIds, config, force = false) {
+    const closed = [];
+    const skipped = [];
+    for (const tabId of tabIds) {
+        try {
+            await WeavetabClose(tabId, config, force);
+            closed.push(tabId);
+        }
+        catch {
+            skipped.push(tabId);
+        }
+    }
+    return { success: true, closed, skipped };
+}
+/**
+ * Consolidate: deduplicate tabs by URL, close duplicates.
+ */
+export async function WeavetabConsolidate(config) {
+    const port = resolvePort(config);
+    const targets = await CDP.List({ host: "127.0.0.1", port });
+    const pages = targets.filter((t) => t.type === "page");
+    const tabsBefore = pages.length;
+    const seenUrls = new Set();
+    let closedDuplicates = 0;
+    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+    for (const page of pages) {
+        if (page.id === activeTargetId) {
+            seenUrls.add(page.url);
+            continue;
+        }
+        if (seenUrls.has(page.url) && page.url !== "about:blank" && page.url !== "") {
+            // Duplicate URL — close it
+            try {
+                await CDP.Close({ host: "127.0.0.1", port, id: page.id });
+                clearTabCache(page.id);
+                sessionRegistry.unregister(page.id);
+                lastActivityMs.delete(page.id);
+                semanticScores.delete(page.id);
+                lockedTabIds.delete(page.id);
+                closedDuplicates++;
+            }
+            catch { /* skip */ }
+        }
+        else {
+            seenUrls.add(page.url);
+        }
+    }
+    const afterTargets = await CDP.List({ host: "127.0.0.1", port });
+    const tabsAfter = afterTargets.filter((t) => t.type === "page").length;
+    logAction("browser_tabs", "consolidate", `${tabsBefore}→${tabsAfter} (closed ${closedDuplicates} duplicates)`);
+    return { success: true, tabs_before: tabsBefore, tabs_after: tabsAfter, closed_duplicates: closedDuplicates };
+}
+/**
+ * Heal: check all tabs for crashed state and reload them.
+ */
+export async function WeavetabHeal(config) {
+    const port = resolvePort(config);
+    const targets = await CDP.List({ host: "127.0.0.1", port });
+    const pages = targets.filter((t) => t.type === "page");
+    let healed = 0;
+    const healthSummary = {};
+    for (const page of pages) {
+        const health = sessionRegistry.getHealth(page.id);
+        healthSummary[page.id] = health;
+        if (health === "dead") {
+            // Dead tab — try reloading via CDP directly
+            try {
+                const crashSession = await CDP({ host: "127.0.0.1", port, target: page.id });
+                await crashSession.Page.reload({ ignoreCache: true });
+                await crashSession.close().catch(() => { });
+                sessionRegistry.beatHeartbeat(page.id);
+                healed++;
+            }
+            catch { /* can't heal this one */ }
+            continue;
+        }
+        try {
+            const client = await connectToTab(page.id);
+            const { result } = await client.session.Runtime.evaluate({
+                expression: `document.readyState`,
+                returnByValue: true,
+            });
+            if (!result?.value || result.value === "uninitialized") {
+                await client.session.Page.reload({ ignoreCache: true });
+                healed++;
+            }
+        }
+        catch {
+            try {
+                const crashSession = await CDP({ host: "127.0.0.1", port, target: page.id });
+                await crashSession.Page.reload({ ignoreCache: true });
+                await crashSession.close().catch(() => { });
+                healed++;
+            }
+            catch { /* can't heal this one */ }
+        }
+    }
+    logAction("browser_tabs", "heal", `healed ${healed}/${pages.length} tabs`);
+    return { success: true, healed, tabs_checked: pages.length, health_summary: healthSummary };
+}
+export async function weaveWindowList(config) {
+    const port = resolvePort(config);
+    const targets = await CDP.List({ host: "127.0.0.1", port });
+    const pages = targets.filter((t) => t.type === "page");
+    // Group by process — each unique window has its own set of tabs
+    // We approximate via CDP Target.getTargets windowId if available
+    const windows = [];
+    const seenWindowIds = new Set();
+    for (const page of pages) {
+        try {
+            const session = await CDP({ host: "127.0.0.1", port, target: page.id });
+            try {
+                const { windowId, bounds } = await session.Browser.getWindowForTarget({ targetId: page.id });
+                if (!seenWindowIds.has(windowId)) {
+                    seenWindowIds.add(windowId);
+                    const activeId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+                    windows.push({
+                        windowId,
+                        state: bounds.windowState || "normal",
+                        bounds: { left: bounds.left, top: bounds.top, width: bounds.width, height: bounds.height },
+                        focused: page.id === activeId,
+                    });
+                }
+            }
+            finally {
+                await session.close().catch(() => { });
+            }
+        }
+        catch { /* skip inaccessible targets */ }
+    }
+    return { windows };
+}
+export async function weaveFocusWindow(windowId, config) {
+    const port = resolvePort(config);
+    const targets = await CDP.List({ host: "127.0.0.1", port });
+    const page = targets.find((t) => t.type === "page");
+    if (!page)
+        throw new Error("No page target found to focus window");
+    const session = await CDP({ host: "127.0.0.1", port, target: page.id });
+    try {
+        await session.Browser.setWindowBounds({ windowId, bounds: { windowState: "normal" } });
+        logAction("browser_tabs", String(windowId), "focused window");
+    }
+    finally {
+        await session.close().catch(() => { });
+    }
+    return { success: true, windowId };
+}

package/dist/tools/thought.d.ts

@@ -0,0 +1,16 @@
+import CDP from "chrome-remote-interface";
+export interface ThoughtOptions {
+    action: "feedback" | "question";
+    message: string;
+    input?: "sentence" | "paragraph";
+    timeout?: number;
+}
+export interface ThoughtResult {
+    success: boolean;
+    response?: string;
+    timeout?: boolean;
+    cancelled?: boolean;
+    status?: "answered" | "cancelled" | "timeout";
+    error?: string;
+}
+export declare function browserThought(session: CDP.Client, args: ThoughtOptions): Promise<ThoughtResult>;

package/dist/tools/thought.js

@@ -0,0 +1,79 @@
+// src/tools/thought.ts
+// browser_thought — agent-to-user communication via green thought bubbles
+// Merged: browser_feedback (one-way) + browser_ask (two-way with input)
+import { logAction } from "../audit/logger.js";
+import { sendToExtension } from "../cdp/helpers.js";
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+export async function browserThought(session, args) {
+    const { action, message, input, timeout } = args;
+    logAction("browser_thought", action, message);
+    if (action === "feedback") {
+        await sendToExtension(session, {
+            type: 'Weavetab_STATE',
+            hud: { action: message },
+            stickyFeedback: true,
+        }).catch(() => { });
+        // Forward to sidepanel thought stream
+        await sendToExtension(session, {
+            type: 'WT_THOUGHT',
+            text: message,
+            kind: 'thought',
+        }).catch(() => { });
+        return { success: true };
+    }
+    if (action === "question") {
+        const QUESTION_TIMEOUT_MS = Math.min((timeout || 20), 20) * 1000;
+        await sendToExtension(session, {
+            type: 'Weavetab_STATE',
+            hud: { action: message },
+            stickyFeedback: true,
+            ask: {
+                input: input || "sentence",
+                timeout: Math.min((timeout || 20), 20),
+            },
+        }).catch(() => { });
+        const start = Date.now();
+        while (Date.now() - start < QUESTION_TIMEOUT_MS + 5000) {
+            await sleep(500);
+            try {
+                const { result } = await session.Runtime.evaluate({
+                    expression: `(() => { try {
+            var el = document.getElementById('__wt_ask_bridge');
+            if (!el || el.dataset.status === 'pending') return null;
+            return JSON.stringify({ status: el.dataset.status, result: el.dataset.result });
+          } catch(e) { return null; } })()`,
+                    returnByValue: true,
+                });
+                if (result?.value) {
+                    const data = JSON.parse(result.value);
+                    if (data.status === 'submitted') {
+                        logAction("browser_thought", "answered", data.result);
+                        await session.Runtime.evaluate({
+                            expression: `(function() {
+                  var el = document.getElementById('__wt_ask_bridge');
+                  if (el) el.remove();
+                })()`
+                        }).catch(() => { });
+                        return { success: true, response: data.result, status: "answered" };
+                    }
+                    if (data.status === 'cancelled') {
+                        logAction("browser_thought", "cancelled", "");
+                        return { success: true, response: "", timeout: true, cancelled: true, status: "cancelled" };
+                    }
+                    if (data.status === 'timeout') {
+                        logAction("browser_thought", "timeout", "");
+                        return { success: true, response: "", timeout: true, status: "timeout" };
+                    }
+                }
+            }
+            catch {
+                // polling error — retry
+            }
+        }
+        logAction("browser_thought", "timeout", "");
+        return { success: true, response: "", timeout: true, status: "timeout" };
+    }
+    return { success: false, error: `Unknown action: ${action}` };
+}

package/dist/tools/type.d.ts

@@ -0,0 +1,65 @@
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+import type { WeaveError } from "./click.js";
+export interface TypeResult {
+    success: true;
+    typed_into: string;
+    ref: string;
+    length: number;
+    execution_ms: number;
+    tab_id: string;
+    url: string;
+    title: string;
+    /** Only present when include_map:true was passed or url_changed is true. */
+    page_map?: string;
+    /** true if any DOM elements changed after typing. */
+    dom_changed: boolean;
+    /** true if dom_changed is false — the page did not respond to this action. */
+    stuck_warning: boolean;
+    /** Guidance when stuck_warning is true. */
+    stuck_hint?: string;
+    /** Sniper warning if multiple matches were found. */
+    sniper_warning?: string;
+    /** true if a high-confidence memory hit was used; false/absent if DOM was resolved normally. */
+    memory_hit?: boolean;
+    /** Rich delta showing exactly what changed */
+    delta?: any;
+    /** SEMANTIC RESPONSE CONTRACT FIELDS */
+    confirmed: boolean;
+    strategy: string;
+    elementState?: Record<string, unknown>;
+    visibleFeedback?: string[];
+    suggestedNext?: string;
+}
+/**
+ * Detect the JavaScript framework used by the current page
+ * This helps determine the best input event strategy
+ */
+export declare function detectFramework(session: CDP.Client): Promise<'react' | 'vue' | 'angular' | 'vanilla'>;
+/**
+ * Framework-aware text injection.
+ * React/Vue controlled inputs require the native prototype setter + InputEvent
+ * to trigger synthetic event reconciliation. Firing a plain Event('input') AFTER
+ * an insertText causes a second state update — the source of triplication.
+ *
+ * Returns true when the native-setter path was taken (caller skips redundant
+ * post-type event dispatch).
+ */
+export declare function frameworkAwareType(session: CDP.Client, objectId: string, text: string, framework: 'react' | 'vue' | 'angular' | 'vanilla'): Promise<boolean>;
+export declare function weaveType(session: CDP.Client, args: {
+    id?: string;
+    label?: string;
+    intent?: string;
+    backendNodeId?: number;
+    x?: number;
+    y?: number;
+    text: string;
+    clearFirst?: boolean;
+    paste?: boolean;
+    /** Typing profile: 'normal' (default) | 'fast' | 'deliberate'. Auto-selected if omitted. */
+    profile?: "fast" | "normal" | "deliberate";
+    /** Set true to include the full updated page_map in the response. Default false. */
+    include_map?: boolean;
+    fast?: boolean;
+    noRetry?: boolean;
+}, config: Config): Promise<TypeResult | WeaveError>;