@weavetab/mcp 2.5.0-beta.0

package/dist/state/agent.d.ts

@@ -0,0 +1,36 @@
+import CDP from "chrome-remote-interface";
+export type GroupState = "idle" | "weaving" | "stuck";
+interface AgentStateCallbacks {
+    onStateChange: (session: CDP.Client | null, state: GroupState, word?: string) => void;
+    onUpdateTabTitle: (session: CDP.Client, state: GroupState) => void;
+}
+declare class AgentStateManager {
+    private state;
+    private word;
+    private idleTimeoutMs;
+    private idleTimer;
+    private callbacks;
+    private session;
+    private errorStreak;
+    constructor(idleTimeoutMs?: number);
+    setCallbacks(cb: AgentStateCallbacks): void;
+    setSession(session: CDP.Client): void;
+    setIdleTimeout(ms: number): void;
+    reportToolCall(): void;
+    reportToolSuccess(): void;
+    reportToolError(): void;
+    reportStuck(word: string): void;
+    reportDone(): void;
+    reportTransportClosed(): void;
+    getState(): {
+        state: GroupState;
+        word: string;
+    };
+    isStuck(): boolean;
+    resetErrorStreak(): void;
+    private transition;
+    private startIdleTimer;
+    private clearIdleTimer;
+}
+export declare const agentState: AgentStateManager;
+export {};

package/dist/state/agent.js

@@ -0,0 +1,101 @@
+class AgentStateManager {
+    state = "idle";
+    word = "";
+    idleTimeoutMs;
+    idleTimer = null;
+    callbacks = null;
+    session = null;
+    errorStreak = 0;
+    constructor(idleTimeoutMs = 60000) {
+        this.idleTimeoutMs = idleTimeoutMs;
+    }
+    setCallbacks(cb) {
+        this.callbacks = cb;
+    }
+    setSession(session) {
+        this.session = session;
+    }
+    setIdleTimeout(ms) {
+        this.idleTimeoutMs = ms;
+    }
+    reportToolCall() {
+        this.clearIdleTimer();
+        if (this.state !== "weaving") {
+            this.transition("weaving");
+        }
+        else {
+            // Always fire onStateChange so activeSessionTabId stays in sync
+            this.callbacks?.onStateChange(this.session, this.state, this.word);
+        }
+        this.startIdleTimer();
+    }
+    reportToolSuccess() {
+        this.errorStreak = 0;
+    }
+    reportToolError() {
+        this.errorStreak++;
+        if (this.errorStreak >= 5) {
+            this.reportStuck("error_streak");
+        }
+    }
+    reportStuck(word) {
+        this.clearIdleTimer();
+        this.word = word;
+        this.transition("stuck", word);
+    }
+    reportDone() {
+        this.clearIdleTimer();
+        this.word = "";
+        this.state = "idle";
+        // Always broadcast — bypasses guard to ensure favicon/tab cleanup
+        this.callbacks?.onStateChange(this.session, "idle");
+        if (this.session)
+            this.callbacks?.onUpdateTabTitle(this.session, "idle");
+    }
+    reportTransportClosed() {
+        this.clearIdleTimer();
+        this.word = "";
+        this.state = "idle";
+        this.callbacks?.onStateChange(this.session, "idle");
+    }
+    getState() {
+        return { state: this.state, word: this.word };
+    }
+    isStuck() {
+        return this.state === "stuck";
+    }
+    resetErrorStreak() {
+        this.errorStreak = 0;
+    }
+    transition(newState, word) {
+        // Always fire the callback for 'idle' so favicon dots get cleared on every tab
+        const isRedundant = this.state === newState && (!word || word === this.word);
+        if (isRedundant && newState !== "idle")
+            return;
+        this.state = newState;
+        if (word !== undefined)
+            this.word = word;
+        this.callbacks?.onStateChange(this.session, this.state, this.word);
+        if (this.session) {
+            this.callbacks?.onUpdateTabTitle(this.session, this.state);
+        }
+    }
+    startIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            this.word = "";
+            this.transition("idle");
+        }, this.idleTimeoutMs);
+        // unref() so this timer does not pin the Node.js event loop. Without this,
+        // the process stays alive indefinitely between tool calls even when the IDE
+        // is idle and nothing else is running.
+        this.idleTimer.unref();
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+}
+export const agentState = new AgentStateManager();

package/dist/state/cache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Weavetab — state/cache.ts
+ * Per-tab action map and box model cache with mutation-based TTL invalidation.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { ActionMap } from "../cdp/walker.js";
+export declare function getCachedActionMap(targetId: string, currentUrl?: string): ActionMap | null;
+export declare function getRawCachedActionMap(targetId: string, currentUrl?: string): ActionMap | null;
+export declare function cacheActionMap(targetId: string, map: ActionMap): void;
+export declare function cacheBoxModel(targetId: string, backendNodeId: number, boxModel: any): void;
+export declare function getCachedBoxModel(targetId: string, backendNodeId: number): any | null;
+export declare function cacheNode(targetId: string, backendNodeId: number, node: any): void;
+export declare function getCachedNode(targetId: string, backendNodeId: number): any | null;
+export declare function clearTabCache(targetId: string): void;
+export declare function registerMutationListener(session: CDP.Client, targetId: string): void;

package/dist/state/cache.js

@@ -0,0 +1,92 @@
+/**
+ * Weavetab — state/cache.ts
+ * Per-tab action map and box model cache with mutation-based TTL invalidation.
+ * Weavetab by fy2ne
+ */
+const tabCache = new Map();
+export function getCachedActionMap(targetId, currentUrl) {
+    const state = tabCache.get(targetId);
+    if (!state)
+        return null;
+    // Ref ID Caching Layer: validity TTL based on DOM mutations
+    if (state.lastMutationTime > state.lastReadTime) {
+        return null; // Mutated since last read, cache invalid
+    }
+    // URL validation to prevent stale cache across page loads/navigations
+    if (currentUrl && state.map && state.map.url !== currentUrl) {
+        return null;
+    }
+    return state.map;
+}
+export function getRawCachedActionMap(targetId, currentUrl) {
+    const state = tabCache.get(targetId);
+    if (!state)
+        return null;
+    if (currentUrl && state.map && state.map.url !== currentUrl) {
+        return null;
+    }
+    return state.map;
+}
+export function cacheActionMap(targetId, map) {
+    const state = tabCache.get(targetId) || { lastMutationTime: 0, lastReadTime: 0, map: null, url: null, boxModels: new Map(), domNodes: new Map() };
+    state.map = map;
+    state.url = map.url;
+    state.lastReadTime = Date.now();
+    tabCache.set(targetId, state);
+}
+export function cacheBoxModel(targetId, backendNodeId, boxModel) {
+    const state = tabCache.get(targetId);
+    if (state)
+        state.boxModels.set(backendNodeId, boxModel);
+}
+export function getCachedBoxModel(targetId, backendNodeId) {
+    const state = tabCache.get(targetId);
+    if (!state || state.lastMutationTime > state.lastReadTime)
+        return null;
+    return state.boxModels.get(backendNodeId) || null;
+}
+export function cacheNode(targetId, backendNodeId, node) {
+    const state = tabCache.get(targetId);
+    if (state)
+        state.domNodes.set(backendNodeId, node);
+}
+export function getCachedNode(targetId, backendNodeId) {
+    const state = tabCache.get(targetId);
+    if (!state || state.lastMutationTime > state.lastReadTime)
+        return null;
+    return state.domNodes.get(backendNodeId) || null;
+}
+export function clearTabCache(targetId) {
+    tabCache.delete(targetId);
+}
+// Smarter Idle Detection: Event-driven MutationObserver
+// Guard: only register listeners once per CDP session object to prevent
+// accumulation when the same session is passed through multiple init paths.
+const registeredSessions = new WeakSet();
+export function registerMutationListener(session, targetId) {
+    // Bail out early if this session already has listeners attached.
+    // Without this guard, connectToTab + initSession could both call this function
+    // for the same session, stacking duplicate listeners that are never removed.
+    if (registeredSessions.has(session))
+        return;
+    registeredSessions.add(session);
+    let debounceTimer;
+    const markMutated = () => {
+        // Debounce to avoid flooding the cache invalidation
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            debounceTimer = undefined;
+            const state = tabCache.get(targetId);
+            if (state) {
+                state.lastMutationTime = Date.now();
+                // Clear box models and dom nodes as they are no longer reliable
+                state.boxModels.clear();
+                state.domNodes.clear();
+            }
+        }, 50); // 50ms debounced quiet window
+    };
+    session.DOM.on("childNodeCountUpdated", markMutated);
+    session.DOM.on("attributeModified", markMutated);
+    session.DOM.on("characterDataModified", markMutated);
+}

package/dist/state/cache.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache.test.d.ts.map

package/dist/state/cache.test.js

@@ -0,0 +1,76 @@
+/**
+ * cache.test.ts — Phase 1.1
+ * Unit tests for action map and box model caching with mutation-based TTL invalidation.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getCachedActionMap, cacheActionMap, cacheBoxModel, getCachedBoxModel, cacheNode, getCachedNode, clearTabCache, } from "./cache.js";
+test("cache: basic action map storage and retrieval", () => {
+    const targetId = "tab-1";
+    const mockMap = {
+        url: "https://example.com",
+        elements: [],
+    };
+    clearTabCache(targetId);
+    assert.equal(getCachedActionMap(targetId), null, "Initial cache miss");
+    cacheActionMap(targetId, mockMap);
+    const retrieved = getCachedActionMap(targetId);
+    assert.ok(retrieved !== null, "Cache hit after storage");
+    assert.equal(retrieved?.url, "https://example.com");
+    clearTabCache(targetId);
+});
+test("cache: URL validation prevents stale cache", () => {
+    const targetId = "tab-2";
+    const mockMap = {
+        url: "https://example.com",
+        elements: [],
+    };
+    cacheActionMap(targetId, mockMap);
+    // Same URL → cache hit
+    assert.ok(getCachedActionMap(targetId, "https://example.com") !== null);
+    // Different URL → cache miss
+    assert.equal(getCachedActionMap(targetId, "https://other.com"), null);
+    clearTabCache(targetId);
+});
+test("cache: box model storage and retrieval", () => {
+    const targetId = "tab-3";
+    const backendNodeId = 12345;
+    const mockBoxModel = { model: { content: [0, 0, 100, 100] } };
+    // First cache an action map to initialize the state
+    cacheActionMap(targetId, { url: "https://example.com", elements: [] });
+    cacheBoxModel(targetId, backendNodeId, mockBoxModel);
+    const retrieved = getCachedBoxModel(targetId, backendNodeId);
+    assert.ok(retrieved !== null, "Box model cached");
+    assert.deepEqual(retrieved, mockBoxModel);
+    clearTabCache(targetId);
+});
+test("cache: node storage and retrieval", () => {
+    const targetId = "tab-4";
+    const backendNodeId = 67890;
+    const mockNode = { nodeId: 67890, nodeName: "DIV" };
+    // First cache an action map to initialize the state
+    cacheActionMap(targetId, { url: "https://example.com", elements: [] });
+    cacheNode(targetId, backendNodeId, mockNode);
+    const retrieved = getCachedNode(targetId, backendNodeId);
+    assert.ok(retrieved !== null, "Node cached");
+    assert.deepEqual(retrieved, mockNode);
+    clearTabCache(targetId);
+});
+test("cache: clearTabCache removes all cached data", () => {
+    const targetId = "tab-5";
+    const mockMap = { url: "https://example.com", elements: [] };
+    const mockBoxModel = { model: { content: [0, 0, 100, 100] } };
+    cacheActionMap(targetId, mockMap);
+    cacheBoxModel(targetId, 12345, mockBoxModel);
+    assert.ok(getCachedActionMap(targetId) !== null);
+    assert.ok(getCachedBoxModel(targetId, 12345) !== null);
+    clearTabCache(targetId);
+    assert.equal(getCachedActionMap(targetId), null);
+    assert.equal(getCachedBoxModel(targetId, 12345), null);
+});
+test("cache: missing cache returns null without error", () => {
+    assert.equal(getCachedActionMap("nonexistent-tab"), null);
+    assert.equal(getCachedBoxModel("nonexistent-tab", 999), null);
+    assert.equal(getCachedNode("nonexistent-tab", 999), null);
+});
+//# sourceMappingURL=cache.test.js.map

package/dist/state/delta.d.ts

@@ -0,0 +1,71 @@
+import type { ActionElement as _ActionElement } from "../cdp/walker.js";
+export type ActionElement = _ActionElement;
+export interface RefEntry {
+    id: string;
+    role: string;
+    label: string;
+    type?: string;
+    value?: string;
+    href?: string;
+    disabled?: boolean;
+    fingerprint: string;
+}
+export interface SnapshotDiff {
+    added: RefEntry[];
+    removed: string[];
+    changed: RefEntry[];
+    stable_count: number;
+    _refs_truncated?: number;
+}
+export interface PropertyDiff {
+    [propName: string]: {
+        from: string;
+        to: string;
+    };
+}
+export interface RichChangedRef {
+    ref: string;
+    role: string;
+    label: string;
+    changes: PropertyDiff;
+    actionable?: boolean;
+    recommended_action?: string;
+}
+export interface IframeChange {
+    frameUrl: string;
+    status: "added" | "removed" | "changed";
+    elementCount: number;
+}
+export interface RichDelta {
+    added: RefEntry[];
+    removed: string[];
+    changed: RichChangedRef[];
+    stable_count: number;
+    iframes?: IframeChange[];
+}
+/**
+ * Store a full snapshot for a tab target.
+ */
+export declare function storeSnapshot(targetId: string, url: string, refs: RefEntry[]): void;
+/**
+ * Eagerly initialize the property snapshot cache for a tab.
+ */
+export declare function seedRichSnapshot(targetId: string, url: string, elements: ActionElement[]): void;
+/**
+ * Compute basic delta.
+ */
+export declare function computeDelta(targetId: string, url: string, newRefs: RefEntry[]): SnapshotDiff | null;
+/**
+ * Rich delta: wraps computeDelta with property-level change details.
+ */
+export declare function computeRichDelta(targetId: string, url: string, newElements: ActionElement[]): Promise<RichDelta | {
+    delta_timeout: true;
+} | null>;
+/**
+ * Clear snapshot for a tab (called on hard navigation).
+ */
+export declare function clearSnapshot(targetId: string): void;
+/**
+ * Clear all snapshots (called on CDP disconnect).
+ */
+export declare function clearAllSnapshots(): void;

package/dist/state/delta.js

@@ -0,0 +1,234 @@
+// src/state/delta.ts
+// Per-tab snapshot diffing for delta reads (Rule 11).
+// weave_read first visit → full snapshot stored here.
+// Subsequent calls → diff against stored snapshot → return only changed refs.
+import { SessionSecretTracker } from "../security/secrets.js";
+const snapshots = new Map();
+const propSnapshots = new Map();
+const frameSnapshots = new Map();
+const INTERACTIVE_ROLES = new Set([
+    'button', 'link', 'textbox', 'searchbox', 'combobox',
+    'checkbox', 'radio', 'menuitem', 'tab', 'select',
+]);
+function serializeProps(el, targetId) {
+    const isSecret = (el.backendNodeId !== undefined && targetId &&
+        SessionSecretTracker.isNodeSecret(targetId, el.backendNodeId)) ||
+        el.label === '[REDACTED]';
+    return {
+        label: isSecret ? '[REDACTED]' : (el.label ?? ''),
+        value: isSecret ? '[REDACTED]' : (el.value ?? ''),
+        disabled: String(!!el.disabled),
+        role: el.role,
+        href: el.href ?? '',
+        placeholder: el.placeholder ?? '',
+        textContent: isSecret ? '[REDACTED]' : (el.textContent ?? ''),
+        className: (el.className ?? '').split(' ').filter(Boolean).sort().join(' '),
+    };
+}
+/**
+ * Store a full snapshot for a tab target.
+ */
+export function storeSnapshot(targetId, url, refs) {
+    const map = new Map();
+    for (const r of refs)
+        map.set(r.id, r);
+    snapshots.set(targetId, { url, refs: map });
+}
+/**
+ * Eagerly initialize the property snapshot cache for a tab.
+ */
+export function seedRichSnapshot(targetId, url, elements) {
+    const propMap = new Map();
+    const snapMap = new Map();
+    const frameMap = new Map();
+    for (const el of elements) {
+        propMap.set(el.id, serializeProps(el, targetId));
+        snapMap.set(el.id, {
+            id: el.id,
+            role: el.role,
+            label: el.label,
+            type: el.type,
+            href: el.href,
+            disabled: el.disabled,
+            value: el.value,
+            fingerprint: el.fingerprint,
+        });
+        const fk = el.frameUrl || '__top__';
+        frameMap.set(fk, (frameMap.get(fk) || 0) + 1);
+    }
+    propSnapshots.set(targetId, { url, props: propMap });
+    snapshots.set(targetId, { url, refs: snapMap });
+    frameSnapshots.set(targetId, frameMap);
+}
+/**
+ * Compute basic delta.
+ */
+export function computeDelta(targetId, url, newRefs) {
+    const prevWrapper = snapshots.get(targetId);
+    if (!prevWrapper || prevWrapper.url !== url)
+        return null;
+    const prev = prevWrapper.refs;
+    const next = new Map();
+    for (const r of newRefs)
+        next.set(r.id, r);
+    // Short-circuit: for maps with 500+ refs, return count-only diff
+    // to avoid O(n) comparison hanging on large pages.
+    if (prev.size > 500) {
+        const addedCount = next.size - prev.size;
+        const removedCount = Array.from(prev.keys()).filter(id => !next.has(id)).length;
+        snapshots.set(targetId, { url, refs: next });
+        return { added: [], removed: [], changed: [], stable_count: Math.min(prev.size, next.size), _refs_truncated: prev.size };
+    }
+    const added = [];
+    const removed = [];
+    const changed = [];
+    let stable_count = 0;
+    for (const [id, ref] of next) {
+        const old = prev.get(id);
+        if (!old) {
+            added.push(ref);
+        }
+        else if (old.label !== ref.label ||
+            old.disabled !== ref.disabled ||
+            old.type !== ref.type ||
+            (ref.value !== undefined && old.value !== ref.value)) {
+            changed.push(ref);
+        }
+        else {
+            stable_count++;
+        }
+    }
+    for (const id of prev.keys()) {
+        if (!next.has(id))
+            removed.push(id);
+    }
+    snapshots.set(targetId, { url, refs: next });
+    return { added, removed, changed, stable_count };
+}
+/**
+ * Rich delta: wraps computeDelta with property-level change details.
+ */
+export async function computeRichDelta(targetId, url, newElements) {
+    // Wrap computation in a 5-second race against a timeout to avoid O(n^2) hangs
+    const computePromise = new Promise((resolve) => {
+        if (!propSnapshots.has(targetId) || propSnapshots.get(targetId).url !== url) {
+            seedRichSnapshot(targetId, url, newElements);
+            resolve(null);
+            return;
+        }
+        const oldPropMap = propSnapshots.get(targetId).props;
+        const newRefs = newElements
+            .filter(el => !el.selector?.includes('data-wt-internal'))
+            .map(el => ({
+            id: el.id,
+            role: el.role,
+            label: el.label,
+            type: el.type,
+            href: el.href,
+            disabled: el.disabled,
+            value: el.value,
+            fingerprint: el.fingerprint,
+        }));
+        const basicDiff = computeDelta(targetId, url, newRefs);
+        if (!basicDiff) {
+            resolve(null);
+            return;
+        }
+        // Compute rich changes with property diffs
+        const richChanged = [];
+        for (const changedRef of basicDiff.changed) {
+            const oldProps = oldPropMap.get(changedRef.id);
+            const newEl = newElements.find(e => e.id === changedRef.id);
+            if (!oldProps || !newEl) {
+                richChanged.push({
+                    ref: changedRef.id,
+                    role: changedRef.role,
+                    label: changedRef.label,
+                    changes: {},
+                });
+                continue;
+            }
+            const newProps = serializeProps(newEl, targetId);
+            const changes = {};
+            for (const key of [...new Set([...Object.keys(oldProps), ...Object.keys(newProps)])]) {
+                if (oldProps[key] !== newProps[key]) {
+                    changes[key] = { from: oldProps[key] ?? '', to: newProps[key] ?? '' };
+                }
+            }
+            const isActionable = INTERACTIVE_ROLES.has(newEl.role);
+            let recommendedAction;
+            if (isActionable) {
+                recommendedAction = newEl.role === 'link' ? 'navigate' : 'click';
+            }
+            richChanged.push({
+                ref: changedRef.id,
+                role: changedRef.role,
+                label: changedRef.label,
+                changes,
+                actionable: isActionable,
+                recommended_action: recommendedAction,
+            });
+        }
+        // ── Phase 5d: Iframe-aware content tracking ──────────────────────────────
+        const newFrameCounts = new Map();
+        for (const el of newElements) {
+            const fk = el.frameUrl || '__top__';
+            newFrameCounts.set(fk, (newFrameCounts.get(fk) || 0) + 1);
+        }
+        const oldFrames = frameSnapshots.get(targetId) || new Map();
+        const iframeChanges = [];
+        // Detect added/changed frames
+        for (const [fk, count] of newFrameCounts) {
+            if (fk === '__top__')
+                continue;
+            const oldCount = oldFrames.get(fk);
+            if (oldCount === undefined) {
+                iframeChanges.push({ frameUrl: fk, status: "added", elementCount: count });
+            }
+            else if (oldCount !== count) {
+                iframeChanges.push({ frameUrl: fk, status: "changed", elementCount: count });
+            }
+        }
+        // Detect removed frames
+        for (const [fk] of oldFrames) {
+            if (fk === '__top__')
+                continue;
+            if (!newFrameCounts.has(fk)) {
+                iframeChanges.push({ frameUrl: fk, status: "removed", elementCount: 0 });
+            }
+        }
+        frameSnapshots.set(targetId, newFrameCounts);
+        // Update property snapshot
+        const newPropMap = new Map();
+        for (const el of newElements) {
+            newPropMap.set(el.id, serializeProps(el, targetId));
+        }
+        propSnapshots.set(targetId, { url, props: newPropMap });
+        resolve({
+            added: basicDiff.added,
+            removed: basicDiff.removed,
+            changed: richChanged,
+            stable_count: basicDiff.stable_count,
+            ...(iframeChanges.length > 0 ? { iframes: iframeChanges } : {}),
+        });
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => resolve({ delta_timeout: true }), 5000);
+    });
+    return Promise.race([computePromise, timeoutPromise]);
+}
+/**
+ * Clear snapshot for a tab (called on hard navigation).
+ */
+export function clearSnapshot(targetId) {
+    snapshots.delete(targetId);
+    frameSnapshots.delete(targetId);
+}
+/**
+ * Clear all snapshots (called on CDP disconnect).
+ */
+export function clearAllSnapshots() {
+    snapshots.clear();
+    propSnapshots.clear();
+    frameSnapshots.clear();
+}

package/dist/state/delta.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=delta.test.d.ts.map