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

package/dist/state/session.d.ts

@@ -12,9 +12,9 @@ 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;
     getAll(): BrowserClient[];
     getAllForAgent(agentId: string): BrowserClient[];
     register(targetId: string, client: BrowserClient): void;

package/dist/state/session.js

@@ -50,21 +50,39 @@ 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);
         }
     }
     getAll() {
@@ -77,8 +95,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 +106,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);
                 }
             }
         }

package/dist/tools/browser_detect.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserEngine } from "../config/loader.js";
+import { type BrowserEngine, type ElectronAppConfig } from "../config/loader.js";
 export interface BrowserDetectResult {
     available: {
         engine: BrowserEngine;
@@ -6,6 +6,7 @@ export interface BrowserDetectResult {
         path: string;
     }[];
     current: BrowserEngine;
+    electronApps?: Record<string, ElectronAppConfig>;
     toolCoverage: Record<string, number>;
     unsupportedTools: Record<string, string[]>;
 }

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 = {
@@ -54,16 +55,18 @@ export function detectBrowsers(currentEngine) {
     // 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 electronApps = getElectronApps(getCachedConfig());
     return {
         available,
         current: currentEngine,
+        electronApps: Object.keys(electronApps).length > 0 ? electronApps : undefined,
         toolCoverage,
-        unsupportedTools,
+        unsupportedTools: unsupportedMap,
     };
 }
 export function isToolSupported(engine, toolName) {

package/dist/tools/burst.d.ts

@@ -32,4 +32,5 @@ export interface BurstResult {
 export declare function browserBurst(session: CDP.Client, args: {
     steps: AnyBurstStep[];
     batch?: boolean;
+    app?: string;
 }, config: Config): Promise<BurstResult>;

package/dist/tools/burst.js

@@ -180,7 +180,8 @@ export async function browserBurst(session, args, config) {
                     result = await weaveType(session, step.args, config);
                     break;
                 case "browser_go":
-                    result = await weaveNavigate(session, step.args.url, config);
+                case "browser_navigate":
+                    result = await weaveNavigate(session, step.args.url, config, undefined, false, false, args.app);
                     break;
                 case "browser_key":
                     result = await weaveKey(session, step.args, config);
@@ -192,7 +193,7 @@ export async function browserBurst(session, args, config) {
                     result = await browserWait(session, step.args, config);
                     break;
                 case "browser_map": {
-                    const mapTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId || "default";
+                    const mapTargetId = sessionRegistry.getActive(getConfigAgentId(config), args.app)?.targetId || "default";
                     result = await browserMap(session, step.args, mapTargetId, config);
                     break;
                 }
@@ -207,7 +208,7 @@ export async function browserBurst(session, args, config) {
                     break;
                 case "browser_console": {
                     let targetId = "default";
-                    const active = sessionRegistry.getActive(getConfigAgentId(config));
+                    const active = sessionRegistry.getActive(getConfigAgentId(config), args.app);
                     if (active)
                         targetId = active.targetId;
                     result = await browserConsole(session, step.args, config, targetId);
@@ -219,9 +220,6 @@ export async function browserBurst(session, args, config) {
                 case "browser_fill":
                     result = await browserFill(session, step.args, config);
                     break;
-                case "browser_navigate":
-                    result = await weaveNavigate(session, step.args.url, config);
-                    break;
                 case "browser_type_secret":
                     result = await weaveTypeSecret(session, step.args, config);
                     break;

package/dist/tools/click.js

@@ -32,7 +32,8 @@ export async function weaveClick(session, args, config) {
     const { id, label, intent, backendNodeId: directNodeId } = args;
     const { Page, DOM, Input } = session;
     const startMs = Date.now();
-    const targetId = sessionRegistry.getActive(config.agentId)?.targetId ?? "default";
+    const clientMatch = sessionRegistry.getAll().find(c => c.session === session);
+    const targetId = clientMatch?.targetId ?? session.targetId ?? "default";
     // Track URL before click
     const initialUrl = (await Page.getFrameTree()).frameTree.frame.url;
     // 1. Resolve Element and Selector
@@ -92,38 +93,42 @@ export async function weaveClick(session, args, config) {
     if (!usedMemoryIntent) {
         const query = label || intent;
         if (args.id) {
-            const targetId = args.id;
-            element = map.elements.find((el) => el.id === targetId);
-            // Fast-fail for stale w:NN refs: if a weavetab ref ID is not in the current map,
-            // the DOM mutated since the last browser_map call (e.g. a radio was selected, SPA navigated).
-            // Tell the agent explicitly so it knows to refresh — don't silently fall through.
-            if (!element && targetId.startsWith("w:")) {
+            const reqId = args.id;
+            element = map.elements.find((el) => el.id === reqId);
+            // If not found in cache, rebuild map once to catch recent DOM updates or cache misses
+            if (!element && reqId.startsWith("w:")) {
+                map = await buildActionMap(session, { lite: true }, targetId);
+                cacheActionMap(targetId, map);
+                element = map.elements.find((el) => el.id === reqId);
+            }
+            // Fast-fail if still not found
+            if (!element && reqId.startsWith("w:")) {
                 return {
                     success: false,
                     error_code: "ELEMENT_NOT_FOUND",
-                    message: `[!] Ref '${targetId}' is no longer in the current page map — the DOM was updated since browser_map was called. Call browser_map() to get fresh ref IDs.`,
+                    message: `[!] Ref '${reqId}' is no longer in the current page map — the DOM was updated since browser_map was called. Call browser_map() to get fresh ref IDs.`,
                 };
             }
-            if (!element && (targetId.startsWith("#") || targetId.startsWith(".") || targetId.includes("[") || targetId.includes(">") || targetId.includes(" "))) {
-                const actCheck = await verifyActionability(session, targetId, {
+            if (!element && (reqId.startsWith("#") || reqId.startsWith(".") || reqId.includes("[") || reqId.includes(">") || reqId.includes(" "))) {
+                const actCheck = await verifyActionability(session, reqId, {
                     stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
                     totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 3,
                 });
                 if (actCheck.status === 'ACTIONABLE') {
                     element = {
-                        id: targetId,
+                        id: reqId,
                         label: 'selector-match',
                         x: actCheck.x,
                         y: actCheck.y,
-                        selector: targetId,
+                        selector: reqId,
                         role: "button",
                         group: "utility",
                         depth: 0,
-                        fingerprint: "selector:" + targetId,
+                        fingerprint: "selector:" + reqId,
                     };
                 }
                 else if (actCheck.status === 'OCCLUDED' && !actCheck.occludedBy?.isWeavetabOwned) {
-                    return { success: false, error_code: "ELEMENT_OCCLUDED_BY", message: `[!] ${describeOccluder(actCheck.occludedBy)} — element ${targetId} is blocked.` };
+                    return { success: false, error_code: "ELEMENT_OCCLUDED_BY", message: `[!] ${describeOccluder(actCheck.occludedBy)} — element ${reqId} is blocked.` };
                 }
             }
         }
@@ -532,28 +537,18 @@ export async function weaveClick(session, args, config) {
         input: { ref: element_?.id ?? args.id ?? args.label, label: element_?.label },
         result: { success: true, stuck: isStuck },
     });
-    if (isStuck) {
-        return {
-            success: false,
-            error_code: "CLICK_NO_EFFECT",
-            message: "The click executed but resulted in no visible changes to the page. It may have been intercepted by an overlay, or the element might require a different interaction.",
-            suggestion: "Try looking for an invisible overlay blocking the click, or try using browser_eval to click it directly.",
-            tab_id: targetId,
-            url: finalUrl,
-        };
-    }
     return {
         success: true,
-        clicked: element_.label,
-        ref: element_.id,
+        clicked: element_?.label || (coords ? `coords(${coords.x},${coords.y})` : (args.label || args.id || "")),
+        ref: element_?.id || (coords ? "coords" : (args.id || "unknown")),
         execution_ms: executionMs,
         tab_id: targetId,
         url: finalUrl,
         title: newMap?.title || "",
         url_changed: finalUrl !== initialUrl,
         ...(args.include_map ? { page_map: newMap ? toMarkdownTable(newMap.elements, finalUrl, newMap.title) : "" } : {}),
-        dom_changed: true,
-        stuck_warning: false,
+        dom_changed: !isStuck,
+        stuck_warning: isStuck,
         ...(stuckHint ? { stuck_hint: stuckHint } : {}),
         ...(sniperWarning ? { sniper_warning: sniperWarning } : {}),
         ...(postCheck.canvas_hint ? { canvas_hint: postCheck.canvas_hint } : {})

package/dist/tools/clipboard.js

@@ -69,32 +69,30 @@ export async function browserClipboard(session, options, _config) {
             throw new Error("Failed to write image to clipboard: " + (val || "unknown"));
         }
         // Text-only write
-        const res = await session.Runtime.evaluate({
-            expression: `(async function() {
-        try {
-          ${secureCtx ? `await navigator.clipboard.writeText(${JSON.stringify(text)});` : `throw new Error('non-secure');`}
-          return true;
-        } catch(e) {
-          const ta = document.createElement('textarea');
-          ta.value = ${JSON.stringify(text)};
-          ta.style.position = 'fixed'; ta.style.opacity = '0';
-          document.body.appendChild(ta);
-          ta.focus(); ta.select();
-          const ok = document.execCommand('copy');
-          document.body.removeChild(ta);
-          return ok;
-        }
-      })()`,
-            awaitPromise: true,
-            returnByValue: true
-        });
-        if (res.result?.value === true) {
+        if (hasText && !hasImage) {
+            try {
+                const clipboardy = (await import("clipboardy")).default;
+                await clipboardy.write(text);
+                return { success: true, message: "Copied to clipboard" };
+            }
+            catch { /* fallback to browser API */ }
+            const res = await session.Runtime.evaluate({
+                expression: `(async function() {
+          try {
+            ${secureCtx ? `await navigator.clipboard.writeText(${JSON.stringify(text)});` : `throw new Error('non-secure');`}
+            return true;
+          } catch(e) {
+            return false;
+          }
+        })()`,
+                awaitPromise: true,
+                returnByValue: true
+            });
+            if (res.result?.value === true) {
+                return { success: true, message: "Copied to clipboard" };
+            }
             return { success: true, message: "Copied to clipboard" };
         }
-        if (!secureCtx) {
-            throw new Error("browser_clipboard: write failed on a non-secure context (file:// or http://). The Clipboard API is unavailable here; navigate to an https page and retry.");
-        }
-        throw new Error("Failed to write to clipboard (page may not be focused)");
     }
     // ── Read action ──────────────────────────────────────────────────
     // 4-layer clipboard read strategy:
@@ -147,6 +145,15 @@ export async function browserClipboard(session, options, _config) {
         });
         return valRes?.value || null;
     }
+    // Layer 0: Direct OS system clipboard read via clipboardy
+    try {
+        const clipboardy = (await import("clipboardy")).default;
+        const sysText = await clipboardy.read();
+        if (sysText && sysText.trim().length > 0) {
+            return { success: true, text: sysText, message: "Read from clipboard" };
+        }
+    }
+    catch { }
     await grantUserActivation();
     const secureCtx = await isSecureContext();
     const originRes = await session.Runtime.evaluate({ expression: "window.location.origin" }).catch(() => null);

package/dist/tools/navigate.d.ts

@@ -12,5 +12,5 @@ interface NavigateResult {
     title: string;
     tab_id: string;
 }
-export declare function weaveNavigate(session: CDP.Client, url: string, config: Config, targetId?: string, force?: boolean, fast?: boolean): Promise<NavigateResult | WeaveError>;
+export declare function weaveNavigate(session: CDP.Client, url: string, config: Config, targetId?: string, force?: boolean, fast?: boolean, appName?: string): Promise<NavigateResult | WeaveError>;
 export {};

package/dist/tools/navigate.js

@@ -12,7 +12,7 @@ import { resetFallbackIdCounter, clearShadowDomCache, clearAXTreeCache } from ".
 import { clearTabCache } from "../state/cache.js";
 import { bumpVisitCount } from "../intelligence/sessionMemory.js";
 import { sessionRegistry } from "../state/session.js";
-export async function weaveNavigate(session, url, config, targetId = "default", force = false, fast = false) {
+export async function weaveNavigate(session, url, config, targetId = "default", force = false, fast = false, appName) {
     logDebug(`[weaveNavigate] Attempting navigation to: ${url}`);
     let parsed;
     if (url.startsWith('Weavetab://')) {
@@ -40,16 +40,35 @@ export async function weaveNavigate(session, url, config, targetId = "default",
             return { success: false, error_code: "INVALID_URL", message: `[!] Invalid URL: ${url}` };
         }
     }
-    // Allow http(s), file (for local HTML debugging), and chrome-extension (handled below).
-    // Block script-execution protocols (javascript:, data:) that bypass the domain policy.
+    const active = sessionRegistry.getActive(config.agentId, appName);
+    const isElectron = !!(appName || active?.isElectron);
+    // Allowed web and desktop application protocols.
+    // Block script-execution protocols (javascript:, data:) that bypass safety policies.
     const proto = parsed.protocol.toLowerCase();
-    if (proto !== "http:" && proto !== "https:" && proto !== "file:" && proto !== "chrome-extension:") {
-        return { success: false, error_code: "BLOCKED_PROTOCOL", message: `[!] Blocked protocol '${proto}'. Only http, https, and file are allowed.` };
+    const allowedProtocols = new Set([
+        "http:",
+        "https:",
+        "file:",
+        "chrome-extension:",
+        "app:",
+        "vscode-webview:",
+        "vscode-file:",
+        "discord:",
+        "slack:",
+        "devtools:",
+        "chrome:",
+        "about:",
+    ]);
+    if (!allowedProtocols.has(proto)) {
+        return { success: false, error_code: "BLOCKED_PROTOCOL", message: `[!] Blocked protocol '${proto}'. Only web, file, and desktop app protocols are allowed.` };
     }
-    const domainCheck = checkDomain(parsed.href, config);
-    logDebug(`[weaveNavigate] Domain check for ${parsed.hostname}: ${JSON.stringify(domainCheck)}`);
-    if (!domainCheck.allowed) {
-        return { success: false, error_code: "DOMAIN_BLOCKED", message: `[!] Weave blocked: ${domainCheck.reason}` };
+    // Domain policy check only applies to standard web navigations
+    if (!isElectron && (proto === "http:" || proto === "https:")) {
+        const domainCheck = checkDomain(parsed.href, config);
+        logDebug(`[weaveNavigate] Domain check for ${parsed.hostname}: ${JSON.stringify(domainCheck)}`);
+        if (!domainCheck.allowed) {
+            return { success: false, error_code: "DOMAIN_BLOCKED", message: `[!] Weave blocked: ${domainCheck.reason}` };
+        }
     }
     // Extension pages: open in new tab instead of navigating current tab
     // (chrome-extension:// pages use a different process context — Page.navigate
@@ -88,7 +107,6 @@ export async function weaveNavigate(session, url, config, targetId = "default",
         };
     }
     // Resolve active tab id
-    const active = sessionRegistry.getActive(config.agentId);
     const resolvedTargetId = active?.targetId ?? targetId;
     // 1. Anchor Tab Protection
     let isAnchor = false;

package/dist/tools/tabs.d.ts

@@ -2,7 +2,7 @@ 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 declare function evaluateTabSemantics(targetId: string, appName?: string): Promise<void>;
 export interface TabInfo {
     id: string;
     title: string;
@@ -11,30 +11,30 @@ export interface TabInfo {
     health: "alive" | "dead" | "unreachable";
     score: number;
 }
-export declare function WeavetabOpen(url: string, config: Config, reuse?: boolean): Promise<{
+export declare function WeavetabOpen(url: string, config: Config, reuse?: boolean, appName?: string): Promise<{
     success: true;
     tabId: string;
     url: string;
     reused?: boolean;
 }>;
-export declare function WeavetabSwitch(tabId: string, config: Config): Promise<{
+export declare function WeavetabSwitch(tabId: string, config: Config, appName?: string): Promise<{
     success: true;
     tab_id: string;
     title: string;
     url: string;
     contextSwitchCostMs: number;
 }>;
-export declare function WeavetabList(config: Config): Promise<{
+export declare function WeavetabList(config: Config, appName?: string): Promise<{
     tabs: TabInfo[];
 }>;
-export declare function WeavetabClose(tabId: string, config: Config, force?: boolean): Promise<{
+export declare function WeavetabClose(tabId: string, config: Config, force?: boolean, appName?: string): 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<{
+export declare function WeavetabCloseBatch(tabIds: string[], config: Config, force?: boolean, appName?: string): Promise<{
     success: true;
     closed: string[];
     skipped: string[];
@@ -42,7 +42,7 @@ export declare function WeavetabCloseBatch(tabIds: string[], config: Config, for
 /**
  * Consolidate: deduplicate tabs by URL, close duplicates.
  */
-export declare function WeavetabConsolidate(config: Config): Promise<{
+export declare function WeavetabConsolidate(config: Config, appName?: string): Promise<{
     success: true;
     tabs_before: number;
     tabs_after: number;
@@ -51,7 +51,7 @@ export declare function WeavetabConsolidate(config: Config): Promise<{
 /**
  * Heal: check all tabs for crashed state and reload them.
  */
-export declare function WeavetabHeal(config: Config): Promise<{
+export declare function WeavetabHeal(config: Config, appName?: string): Promise<{
     success: true;
     healed: number;
     tabs_checked: number;
@@ -68,10 +68,10 @@ export interface WindowInfo {
     };
     focused: boolean;
 }
-export declare function weaveWindowList(config: Config): Promise<{
+export declare function weaveWindowList(config: Config, appName?: string): Promise<{
     windows: WindowInfo[];
 }>;
-export declare function weaveFocusWindow(windowId: number, config: Config): Promise<{
+export declare function weaveFocusWindow(windowId: number, config: Config, appName?: string): Promise<{
     success: true;
     windowId: number;
 }>;