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

package/dist/state/agent.d.ts

@@ -15,6 +15,7 @@ declare class AgentStateManager {
     constructor(idleTimeoutMs?: number);
     setCallbacks(cb: AgentStateCallbacks): void;
     setSession(session: CDP.Client): void;
+    getSession(): CDP.Client | null;
     setIdleTimeout(ms: number): void;
     reportToolCall(): void;
     reportToolSuccess(): void;

package/dist/state/agent.js

@@ -15,6 +15,9 @@ class AgentStateManager {
     setSession(session) {
         this.session = session;
     }
+    getSession() {
+        return this.session;
+    }
     setIdleTimeout(ms) {
         this.idleTimeoutMs = ms;
     }

package/dist/state/delta.d.ts

@@ -46,19 +46,19 @@ export interface RichDelta {
 /**
  * Store a full snapshot for a tab target.
  */
-export declare function storeSnapshot(targetId: string, url: string, refs: RefEntry[]): void;
+export declare function storeSnapshot(targetId: string, urlOrRefs: string | RefEntry[], maybeRefs?: RefEntry[]): void;
 /**
  * Eagerly initialize the property snapshot cache for a tab.
  */
-export declare function seedRichSnapshot(targetId: string, url: string, elements: ActionElement[]): void;
+export declare function seedRichSnapshot(targetId: string, urlOrElements: string | ActionElement[], maybeElements?: ActionElement[]): void;
 /**
  * Compute basic delta.
  */
-export declare function computeDelta(targetId: string, url: string, newRefs: RefEntry[]): SnapshotDiff | null;
+export declare function computeDelta(targetId: string, urlOrNewRefs: string | RefEntry[], maybeNewRefs?: RefEntry[]): SnapshotDiff | null;
 /**
  * Rich delta: wraps computeDelta with property-level change details.
  */
-export declare function computeRichDelta(targetId: string, url: string, newElements: ActionElement[]): Promise<RichDelta | {
+export declare function computeRichDelta(targetId: string, urlOrNewElements: string | ActionElement[], maybeNewElements?: ActionElement[]): Promise<RichDelta | {
     delta_timeout: true;
 } | null>;
 /**
@@ -69,3 +69,11 @@ export declare function clearSnapshot(targetId: string): void;
  * Clear all snapshots (called on CDP disconnect).
  */
 export declare function clearAllSnapshots(): void;
+/**
+ * Get stored ref entry from snapshot for recovery of detached nodes.
+ */
+export declare function getStoredRef(targetId: string, refId: string): RefEntry | undefined;
+/**
+ * Get stored element properties from rich snapshot for recovery.
+ */
+export declare function getStoredProps(targetId: string, refId: string): Record<string, string> | undefined;

package/dist/state/delta.js

@@ -3,6 +3,7 @@
 // weave_read first visit → full snapshot stored here.
 // Subsequent calls → diff against stored snapshot → return only changed refs.
 import { SessionSecretTracker } from "../security/secrets.js";
+import { hookPipeline } from "../plugin/pipeline.js";
 const snapshots = new Map();
 const propSnapshots = new Map();
 const frameSnapshots = new Map();
@@ -13,22 +14,27 @@ const INTERACTIVE_ROLES = new Set([
 function serializeProps(el, targetId) {
     const isSecret = (el.backendNodeId !== undefined && targetId &&
         SessionSecretTracker.isNodeSecret(targetId, el.backendNodeId)) ||
-        el.label === '[REDACTED]';
+        el.label === '[REDACTED]' ||
+        el.value === '[REDACTED]' ||
+        el.role === 'password' ||
+        el.type === 'password';
     return {
-        label: isSecret ? '[REDACTED]' : (el.label ?? ''),
-        value: isSecret ? '[REDACTED]' : (el.value ?? ''),
+        label: isSecret ? '[REDACTED]' : (targetId ? SessionSecretTracker.redact(targetId, el.label ?? '') : (el.label ?? '')),
+        value: isSecret ? '[REDACTED]' : (targetId ? SessionSecretTracker.redact(targetId, el.value ?? '') : (el.value ?? '')),
         disabled: String(!!el.disabled),
         role: el.role,
         href: el.href ?? '',
-        placeholder: el.placeholder ?? '',
-        textContent: isSecret ? '[REDACTED]' : (el.textContent ?? ''),
+        placeholder: isSecret ? '[REDACTED]' : (targetId ? SessionSecretTracker.redact(targetId, el.placeholder ?? '') : (el.placeholder ?? '')),
+        textContent: isSecret ? '[REDACTED]' : (targetId ? SessionSecretTracker.redact(targetId, el.textContent ?? '') : (el.textContent ?? '')),
         className: (el.className ?? '').split(' ').filter(Boolean).sort().join(' '),
     };
 }
 /**
  * Store a full snapshot for a tab target.
  */
-export function storeSnapshot(targetId, url, refs) {
+export function storeSnapshot(targetId, urlOrRefs, maybeRefs) {
+    const url = typeof urlOrRefs === 'string' ? urlOrRefs : '';
+    const refs = Array.isArray(urlOrRefs) ? urlOrRefs : (maybeRefs || []);
     const map = new Map();
     for (const r of refs)
         map.set(r.id, r);
@@ -37,7 +43,9 @@ export function storeSnapshot(targetId, url, refs) {
 /**
  * Eagerly initialize the property snapshot cache for a tab.
  */
-export function seedRichSnapshot(targetId, url, elements) {
+export function seedRichSnapshot(targetId, urlOrElements, maybeElements) {
+    const url = typeof urlOrElements === 'string' ? urlOrElements : '';
+    const elements = Array.isArray(urlOrElements) ? urlOrElements : (maybeElements || []);
     const propMap = new Map();
     const snapMap = new Map();
     const frameMap = new Map();
@@ -63,9 +71,13 @@ export function seedRichSnapshot(targetId, url, elements) {
 /**
  * Compute basic delta.
  */
-export function computeDelta(targetId, url, newRefs) {
+export function computeDelta(targetId, urlOrNewRefs, maybeNewRefs) {
+    const url = typeof urlOrNewRefs === 'string' ? urlOrNewRefs : '';
+    const newRefs = Array.isArray(urlOrNewRefs) ? urlOrNewRefs : (maybeNewRefs || []);
     const prevWrapper = snapshots.get(targetId);
-    if (!prevWrapper || prevWrapper.url !== url)
+    if (!prevWrapper)
+        return null;
+    if (url && prevWrapper.url && prevWrapper.url !== url)
         return null;
     const prev = prevWrapper.refs;
     const next = new Map();
@@ -103,15 +115,30 @@ export function computeDelta(targetId, url, newRefs) {
             removed.push(id);
     }
     snapshots.set(targetId, { url, refs: next });
-    return { added, removed, changed, stable_count };
+    const diff = { added, removed, changed, stable_count };
+    if (added.length > 0 || removed.length > 0 || changed.length > 0) {
+        hookPipeline.dispatchDOMMutation({
+            type: "dom_diff",
+            timestamp: Date.now(),
+            url,
+            added,
+            removed,
+            changed,
+            stable_count,
+            significantChange: added.length > 0 || changed.length > 0,
+        }).catch(() => { });
+    }
+    return diff;
 }
 /**
  * Rich delta: wraps computeDelta with property-level change details.
  */
-export async function computeRichDelta(targetId, url, newElements) {
+export async function computeRichDelta(targetId, urlOrNewElements, maybeNewElements) {
+    const url = typeof urlOrNewElements === 'string' ? urlOrNewElements : '';
+    const newElements = Array.isArray(urlOrNewElements) ? urlOrNewElements : (maybeNewElements || []);
     // 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) {
+        if (!propSnapshots.has(targetId) || (url && propSnapshots.get(targetId).url && propSnapshots.get(targetId).url !== url)) {
             seedRichSnapshot(targetId, url, newElements);
             resolve(null);
             return;
@@ -204,13 +231,27 @@ export async function computeRichDelta(targetId, url, newElements) {
             newPropMap.set(el.id, serializeProps(el, targetId));
         }
         propSnapshots.set(targetId, { url, props: newPropMap });
-        resolve({
+        const richResult = {
             added: basicDiff.added,
             removed: basicDiff.removed,
             changed: richChanged,
             stable_count: basicDiff.stable_count,
             ...(iframeChanges.length > 0 ? { iframes: iframeChanges } : {}),
-        });
+        };
+        if (basicDiff.added.length > 0 || basicDiff.removed.length > 0 || richChanged.length > 0) {
+            hookPipeline.dispatchDOMMutation({
+                type: "rich_delta",
+                timestamp: Date.now(),
+                url,
+                added: basicDiff.added,
+                removed: basicDiff.removed,
+                changed: richChanged,
+                stable_count: basicDiff.stable_count,
+                iframes: iframeChanges,
+                significantChange: basicDiff.added.length > 0 || richChanged.some(c => c.actionable),
+            }).catch(() => { });
+        }
+        resolve(richResult);
     });
     const timeoutPromise = new Promise((resolve) => {
         setTimeout(() => resolve({ delta_timeout: true }), 5000);
@@ -232,3 +273,15 @@ export function clearAllSnapshots() {
     propSnapshots.clear();
     frameSnapshots.clear();
 }
+/**
+ * Get stored ref entry from snapshot for recovery of detached nodes.
+ */
+export function getStoredRef(targetId, refId) {
+    return snapshots.get(targetId)?.refs.get(refId);
+}
+/**
+ * Get stored element properties from rich snapshot for recovery.
+ */
+export function getStoredProps(targetId, refId) {
+    return propSnapshots.get(targetId)?.props.get(refId);
+}

package/dist/state/session.d.ts

@@ -12,9 +12,15 @@ export declare class SessionRegistry {
     getBrowserContextIdForAgent(agentId: string): string | undefined;
     getAgentForBrowserContextId(contextId: string): string | undefined;
     setBrowserContextIdForAgent(agentId: string, contextId: string): void;
-    getActive(agentId?: string): BrowserClient | null;
+    getActive(agentId?: string, appName?: string): BrowserClient | null;
     getMostRecent(agentId?: string): BrowserClient | null;
-    setActive(targetId: string, agentId: string): void;
+    setActive(targetId: string, agentId: string, appName?: string): void;
+    private lastActiveApp;
+    getLastActiveApp(): string | null;
+    setLastActiveApp(app?: string | null): void;
+    findClientByTargetId(targetId: string): BrowserClient | null;
+    getActiveElectronClients(): BrowserClient[];
+    isBrowserSessionActive(): boolean;
     getAll(): BrowserClient[];
     getAllForAgent(agentId: string): BrowserClient[];
     register(targetId: string, client: BrowserClient): void;

package/dist/state/session.js

@@ -50,23 +50,67 @@ export class SessionRegistry {
         this.browserContextsByAgent.set(agentId, contextId);
         this.savePersistence();
     }
-    getActive(agentId) {
+    getActive(agentId, appName) {
         if (!agentId)
             return null;
-        const targetId = this.activeTargetIdByAgent.get(agentId);
-        if (!targetId)
-            return null;
-        return this.sessions.get(targetId) || null;
+        const key = appName ? `${agentId}:app:${appName}` : agentId;
+        const targetId = this.activeTargetIdByAgent.get(key);
+        if (targetId && this.sessions.has(targetId)) {
+            return this.sessions.get(targetId) || null;
+        }
+        if (appName) {
+            const match = Array.from(this.sessions.values()).find(c => c.agentId === agentId && c.appName === appName);
+            if (match)
+                return match;
+        }
+        else {
+            const browserTargetId = this.activeTargetIdByAgent.get(agentId);
+            if (browserTargetId) {
+                const client = this.sessions.get(browserTargetId);
+                if (client && !client.isElectron)
+                    return client;
+            }
+        }
+        return null;
     }
     getMostRecent(agentId) {
         const values = Array.from(this.sessions.values()).filter(c => c.agentId === agentId);
         return values.length > 0 ? values[values.length - 1] : null;
     }
-    setActive(targetId, agentId) {
+    setActive(targetId, agentId, appName) {
         if (this.sessions.has(targetId)) {
-            this.activeTargetIdByAgent.set(agentId, targetId);
+            const client = this.sessions.get(targetId);
+            const targetApp = appName || client?.appName;
+            const key = targetApp ? `${agentId}:app:${targetApp}` : agentId;
+            this.activeTargetIdByAgent.set(key, targetId);
+        }
+    }
+    lastActiveApp = null;
+    getLastActiveApp() {
+        return this.lastActiveApp;
+    }
+    setLastActiveApp(app) {
+        if (!app) {
+            this.lastActiveApp = null;
+            return;
+        }
+        const low = app.toLowerCase();
+        if (low !== "browser" && low !== "chrome" && low !== "chromium") {
+            this.lastActiveApp = low;
+        }
+        else {
+            this.lastActiveApp = null;
         }
     }
+    findClientByTargetId(targetId) {
+        return this.sessions.get(targetId) || null;
+    }
+    getActiveElectronClients() {
+        return Array.from(this.sessions.values()).filter(c => c.isElectron);
+    }
+    isBrowserSessionActive() {
+        return Array.from(this.sessions.values()).some(c => !c.isElectron);
+    }
     getAll() {
         return Array.from(this.sessions.values());
     }
@@ -77,8 +121,9 @@ export class SessionRegistry {
         this.sessions.set(targetId, client);
         this.heartbeatTimestamps.set(targetId, Date.now());
         this.startHeartbeat(targetId, client.session);
-        if (!this.activeTargetIdByAgent.has(client.agentId)) {
-            this.activeTargetIdByAgent.set(client.agentId, targetId);
+        const key = client.appName ? `${client.agentId}:app:${client.appName}` : client.agentId;
+        if (!this.activeTargetIdByAgent.has(key)) {
+            this.activeTargetIdByAgent.set(key, targetId);
         }
     }
     unregister(targetId) {
@@ -87,14 +132,15 @@ export class SessionRegistry {
         if (client) {
             client.session.close().catch(() => { });
             this.sessions.delete(targetId);
-            const activeForAgent = this.activeTargetIdByAgent.get(client.agentId);
+            const key = client.appName ? `${client.agentId}:app:${client.appName}` : client.agentId;
+            const activeForAgent = this.activeTargetIdByAgent.get(key);
             if (activeForAgent === targetId) {
-                const agentTabs = Array.from(this.sessions.values()).filter(c => c.agentId === client.agentId);
+                const agentTabs = Array.from(this.sessions.values()).filter(c => c.agentId === client.agentId && c.appName === client.appName);
                 if (agentTabs.length > 0) {
-                    this.activeTargetIdByAgent.set(client.agentId, agentTabs[agentTabs.length - 1].targetId);
+                    this.activeTargetIdByAgent.set(key, agentTabs[agentTabs.length - 1].targetId);
                 }
                 else {
-                    this.activeTargetIdByAgent.delete(client.agentId);
+                    this.activeTargetIdByAgent.delete(key);
                 }
             }
         }
@@ -131,6 +177,7 @@ export class SessionRegistry {
                 // heartbeat failed — tab may be dead, will be caught by getHealth()
             }
         }, HEARTBEAT_INTERVAL_MS);
+        interval.unref();
         this.heartbeatIntervals.set(targetId, interval);
     }
     stopHeartbeat(targetId) {

package/dist/tools/browser_detect.d.ts

@@ -1,4 +1,16 @@
-import type { BrowserEngine } from "../config/loader.js";
+import { type BrowserEngine } from "../config/loader.js";
+import { type DiscoveredElectronApp } from "../desktop/discovery.js";
+export interface ConfiguredAppStatus {
+    name: string;
+    status: "connected" | "running_no_debug" | "offline";
+    configuredPath?: string;
+    activeTabs?: {
+        id: string;
+        title: string;
+        url: string;
+    }[];
+    port?: number;
+}
 export interface BrowserDetectResult {
     available: {
         engine: BrowserEngine;
@@ -6,8 +18,10 @@ export interface BrowserDetectResult {
         path: string;
     }[];
     current: BrowserEngine;
+    configuredApps?: ConfiguredAppStatus[];
+    runningUnconfiguredApps?: DiscoveredElectronApp[];
     toolCoverage: Record<string, number>;
     unsupportedTools: Record<string, string[]>;
 }
-export declare function detectBrowsers(currentEngine: BrowserEngine): BrowserDetectResult;
+export declare function detectBrowsers(currentEngine: BrowserEngine): Promise<BrowserDetectResult>;
 export declare function isToolSupported(engine: BrowserEngine, toolName: string): boolean;

package/dist/tools/browser_detect.js

@@ -1,4 +1,5 @@
 import { findFirefox, probeAllBrowsers } from "../cdp/bridge.js";
+import { getCachedConfig, getElectronApps } from "../config/loader.js";
 // Phase 8c: Per-engine tool coverage map
 // Firefox CDP is ~80% feature-complete; WebKit is ~60%
 const ENGINE_COVERAGE = {
@@ -39,7 +40,11 @@ const ENGINE_COVERAGE = {
         ],
     },
 };
-export function detectBrowsers(currentEngine) {
+import { sessionRegistry } from "../state/session.js";
+import { getTabList } from "../cdp/connector.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { discoverElectronApps } from "../desktop/discovery.js";
+export async function detectBrowsers(currentEngine) {
     const available = [];
     // Detect Chromium-based browsers
     const allBrowsers = probeAllBrowsers();
@@ -51,19 +56,62 @@ export function detectBrowsers(currentEngine) {
     if (ff) {
         available.push({ engine: "firefox", name: ff.name, path: ff.path });
     }
-    // WebKit detection is best-effort (Safari Technology Preview)
-    // We do not auto-detect WebKit — only report if manually configured
     const toolCoverage = {};
-    const unsupportedTools = {};
+    const unsupportedMap = {};
     for (const engine of ["chromium", "firefox", "webkit"]) {
         toolCoverage[engine] = ENGINE_COVERAGE[engine].coverage;
-        unsupportedTools[engine] = [...ENGINE_COVERAGE[engine].unsupported];
+        unsupportedMap[engine] = [...ENGINE_COVERAGE[engine].unsupported];
+    }
+    const config = getCachedConfig();
+    const electronApps = getElectronApps(config);
+    const runningElectronApps = await discoverElectronApps().catch(() => []);
+    const configuredApps = [];
+    const runningUnconfiguredApps = [];
+    // Identify configured app statuses
+    for (const [appName, appCfg] of Object.entries(electronApps)) {
+        const clients = sessionRegistry.getAllForAgent(getConfigAgentId(config));
+        const activeClient = clients.find(c => c.isElectron && c.appName === appName);
+        let status = "offline";
+        let activeTabs = [];
+        let port;
+        if (activeClient) {
+            status = "connected";
+            port = activeClient.port;
+            try {
+                const tabs = await getTabList(getConfigAgentId(config), appName);
+                activeTabs = tabs.map(t => ({ id: t.id, title: t.title, url: t.url }));
+            }
+            catch { /* ignore tab list failure */ }
+        }
+        else {
+            const running = runningElectronApps.find(r => r.name.toLowerCase() === appName.toLowerCase());
+            if (running) {
+                status = running.status === "debug_port_open" ? "connected" : "running_no_debug";
+                port = running.port;
+            }
+        }
+        configuredApps.push({
+            name: appName,
+            status,
+            configuredPath: appCfg.path,
+            activeTabs: activeTabs.length > 0 ? activeTabs : undefined,
+            port
+        });
+    }
+    // Find running apps that are not configured
+    for (const running of runningElectronApps) {
+        const isConfigured = Object.keys(electronApps).some(n => n.toLowerCase() === running.name.toLowerCase());
+        if (!isConfigured) {
+            runningUnconfiguredApps.push(running);
+        }
     }
     return {
         available,
         current: currentEngine,
+        configuredApps: configuredApps.length > 0 ? configuredApps : undefined,
+        runningUnconfiguredApps: runningUnconfiguredApps.length > 0 ? runningUnconfiguredApps : undefined,
         toolCoverage,
-        unsupportedTools,
+        unsupportedTools: unsupportedMap,
     };
 }
 export function isToolSupported(engine, toolName) {

package/dist/tools/burst.d.ts

@@ -5,16 +5,26 @@
  */
 import CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
+import { type TrailEntry } from "../intelligence/trail.js";
 export interface BurstStep {
-    tool: "browser_click" | "browser_type" | "browser_go" | "browser_navigate" | "browser_key" | "browser_scroll" | "browser_wait" | "browser_map" | "browser_pointer" | "browser_eval" | "browser_select" | "browser_console" | "browser_find" | "browser_fill" | "browser_type_secret" | "browser_screenshot" | "browser_inspect" | "browser_storage" | "browser_cookies" | "browser_highlight" | "browser_scrape" | "browser_canvas" | "browser_performance" | "browser_snapshot" | "browser_pdf" | "browser_dialog" | "browser_upload" | "browser_viewport" | "browser_clipboard" | "browser_detect" | "browser_recording" | "browser_automation";
+    tool: string;
     args: Record<string, unknown>;
 }
-/** Macro step types — expanded server-side into multiple primitive calls. */
 export interface BurstMacroStep {
-    tool: "type_and_send" | "navigate_and_read" | "click_and_wait" | "scroll_and_read" | "fill_form" | "drag_and_drop" | "hover_and_read";
+    tool: "type_and_send" | "navigate_and_read" | "click_and_wait" | "scroll_and_read" | "fill_form" | "drag_and_drop" | "hover_and_read" | string;
     args: Record<string, unknown>;
 }
 export type AnyBurstStep = BurstStep | BurstMacroStep;
+export interface BurstOptions {
+    steps?: AnyBurstStep[];
+    actions?: AnyBurstStep[];
+    compile_from_history?: boolean;
+    history_limit?: number;
+    dry_run?: boolean;
+    stop_on_error?: boolean;
+    batch?: boolean;
+    app?: string;
+}
 export interface BurstStepResult {
     step: number;
     tool: string;
@@ -28,8 +38,8 @@ export interface BurstResult {
     results: BurstStepResult[];
     aborted: boolean;
     abort_reason?: string;
+    compiled_steps?: AnyBurstStep[];
+    message?: string;
 }
-export declare function browserBurst(session: CDP.Client, args: {
-    steps: AnyBurstStep[];
-    batch?: boolean;
-}, config: Config): Promise<BurstResult>;
+export declare function compileTraceToMacro(steps: TrailEntry[]): AnyBurstStep[];
+export declare function browserBurst(session: CDP.Client, args: BurstOptions, config: Config): Promise<BurstResult>;