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

package/dist/tools/snapshot.js

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
 import { getOutputDir, getConfigAgentId } from "../config/loader.js";
-import { hideWeaveTabOverlay, restoreWeaveTabOverlay } from "../cdp/helpers.js";
+import { hideWeaveTabOverlay, restoreWeaveTabOverlay, maskSecretFieldsForCapture, restoreSecretFieldsAfterCapture } from "../cdp/helpers.js";
 import { clearTabCache } from "../state/cache.js";
 import { clearSnapshot } from "../state/delta.js";
 import { sessionRegistry } from "../state/session.js";
@@ -28,22 +28,7 @@ export async function browserSnapshot(session, options, config) {
         }
         // ── Blank secret field values before capture ──────────────────────────
         // Prevents credential values from being embedded in the MHTML archive.
-        // data-wt-secret is set by browser_type_secret at injection time.
-        await session.Runtime.evaluate({
-            expression: `(function() {
-        var els = document.querySelectorAll('[data-wt-secret], input[type="password"]');
-        for (var i = 0; i < els.length; i++) {
-          var el = els[i];
-          el.__wt_snap_backup = el.value;
-          try { el.value = ''; } catch(e) {}
-          if (el.isContentEditable) {
-            el.__wt_snap_text_backup = el.textContent;
-            try { el.textContent = ''; } catch(e) {}
-          }
-        }
-      })()`,
-            returnByValue: false,
-        }).catch(() => { });
+        await maskSecretFieldsForCapture(session);
         let snapshotData;
         try {
             const res = await session.Page.captureSnapshot({ format: "mhtml" });
@@ -51,26 +36,10 @@ export async function browserSnapshot(session, options, config) {
         }
         finally {
             // ── Restore secret field values after capture (always runs) ──────────
+            await restoreSecretFieldsAfterCapture(session);
             if (shouldHide) {
                 await restoreWeaveTabOverlay(session);
             }
-            await session.Runtime.evaluate({
-                expression: `(function() {
-          var els = document.querySelectorAll('[data-wt-secret], input[type="password"]');
-          for (var i = 0; i < els.length; i++) {
-            var el = els[i];
-            if (el.__wt_snap_backup !== undefined) {
-              try { el.value = el.__wt_snap_backup; } catch(e) {}
-              delete el.__wt_snap_backup;
-            }
-            if (el.__wt_snap_text_backup !== undefined) {
-              try { el.textContent = el.__wt_snap_text_backup; } catch(e) {}
-              delete el.__wt_snap_text_backup;
-            }
-          }
-        })()`,
-                returnByValue: false,
-            }).catch(() => { });
         }
         await fs.mkdir(path.dirname(filePath), { recursive: true });
         await fs.writeFile(filePath, snapshotData, "utf8");

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;
 }>;

package/dist/tools/tabs.js

@@ -8,7 +8,13 @@ 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) {
+function resolvePort(_config, appName) {
+    if (appName) {
+        const lock = readLock(appName);
+        if (lock && lock.port)
+            return lock.port;
+        throw new Error(`[!] No active session for Electron app "${appName}". Launch it first.`);
+    }
     const port = getPort() || readLock()?.port;
     if (!port)
         throw new Error("[!] No active browser session. Run browser_go first.");
@@ -44,9 +50,9 @@ function calculateSemanticScore(url, title) {
         score += 30;
     return Math.min(score, 100);
 }
-export async function evaluateTabSemantics(targetId) {
+export async function evaluateTabSemantics(targetId, appName) {
     try {
-        const client = await connectToTab(targetId);
+        const client = await connectToTab(targetId, undefined, undefined, undefined, appName);
         const result = await client.session.Runtime.evaluate({
             expression: `JSON.stringify({ title: document.title, url: location.href })`,
             returnByValue: true
@@ -104,17 +110,25 @@ async function enforceMaxTabs(config) {
     logAction("browser_tabs", victim.id, `auto-closed idle tab: ${victim.title}`);
 }
 // ─── Tools ────────────────────────────────────────────────────────────────────
-export async function WeavetabOpen(url, config, reuse = true) {
-    const port = resolvePort(config);
+export async function WeavetabOpen(url, config, reuse = true, appName) {
+    // Infer appName from active session if omitted
+    let resolvedAppName = appName;
+    if (!resolvedAppName) {
+        const lastApp = sessionRegistry.getLastActiveApp();
+        if (lastApp) {
+            resolvedAppName = lastApp;
+        }
+    }
+    const port = resolvePort(config, resolvedAppName);
     // Tab reuse: if same URL is already open, focus it instead of duplicating
     if (reuse && url) {
         try {
-            const targets = await getTabList(getConfigAgentId(config));
+            const targets = await getTabList(getConfigAgentId(config), resolvedAppName);
             const existing = targets.find((t) => t.url === url);
             if (existing) {
-                const client = await connectToTab(existing.id);
+                const client = await connectToTab(existing.id, undefined, undefined, undefined, resolvedAppName);
                 await client.session.Target.activateTarget({ targetId: existing.id });
-                sessionRegistry.setActive(existing.id, getConfigAgentId(config));
+                sessionRegistry.setActive(existing.id, getConfigAgentId(config), resolvedAppName);
                 recordTabActivity(existing.id);
                 logAction("browser_tabs", url, `reused existing tab ${existing.id}`);
                 return { success: true, tabId: existing.id, url, reused: true };
@@ -122,22 +136,24 @@ export async function WeavetabOpen(url, config, reuse = true) {
         }
         catch { /* fall through to open new */ }
     }
-    await enforceMaxTabs(config);
-    const bctxId = sessionRegistry.getBrowserContextIdForAgent(getConfigAgentId(config));
+    if (!resolvedAppName) {
+        await enforceMaxTabs(config);
+    }
+    const bctxId = resolvedAppName ? undefined : 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);
+    await connectToTab(targetId, port, getConfigAgentId(config), bctxId, appName);
+    await evaluateTabSemantics(targetId, appName);
     logAction("browser_tabs", url, `opened ${targetId}`);
     return { success: true, tabId: targetId, url };
 }
-export async function WeavetabSwitch(tabId, config) {
-    const client = await connectToTab(tabId);
+export async function WeavetabSwitch(tabId, config, appName) {
+    const client = await connectToTab(tabId, undefined, undefined, undefined, appName);
     const startSwitch = Date.now();
     await client.session.Target.activateTarget({ targetId: tabId });
-    sessionRegistry.setActive(tabId, getConfigAgentId(config));
+    sessionRegistry.setActive(tabId, getConfigAgentId(config), appName);
     recordTabActivity(tabId);
     const { frameTree } = await client.session.Page.getFrameTree();
     let title = tabId;
@@ -154,9 +170,9 @@ export async function WeavetabSwitch(tabId, config) {
     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;
+export async function WeavetabList(config, appName) {
+    const targets = await getTabList(getConfigAgentId(config), appName);
+    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config), appName)?.targetId;
     const tabs = targets
         .map((t) => ({
         id: t.id,
@@ -174,12 +190,12 @@ export async function WeavetabList(config) {
     }));
     return { tabs };
 }
-export async function WeavetabClose(tabId, config, force = false) {
+export async function WeavetabClose(tabId, config, force = false, appName) {
     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);
+    const port = resolvePort(config, appName);
     await CDP.Close({ host: "127.0.0.1", port, id: tabId });
     clearTabCache(tabId);
     sessionRegistry.unregister(tabId);
@@ -192,12 +208,12 @@ export async function WeavetabClose(tabId, config, force = false) {
 /**
  * Batch close multiple tabs at once — saves multiple round-trips.
  */
-export async function WeavetabCloseBatch(tabIds, config, force = false) {
+export async function WeavetabCloseBatch(tabIds, config, force = false, appName) {
     const closed = [];
     const skipped = [];
     for (const tabId of tabIds) {
         try {
-            await WeavetabClose(tabId, config, force);
+            await WeavetabClose(tabId, config, force, appName);
             closed.push(tabId);
         }
         catch {
@@ -209,14 +225,14 @@ export async function WeavetabCloseBatch(tabIds, config, force = false) {
 /**
  * Consolidate: deduplicate tabs by URL, close duplicates.
  */
-export async function WeavetabConsolidate(config) {
-    const port = resolvePort(config);
+export async function WeavetabConsolidate(config, appName) {
+    const port = resolvePort(config, appName);
     const targets = await CDP.List({ host: "127.0.0.1", port });
-    const pages = targets.filter((t) => t.type === "page");
+    const pages = targets.filter((t) => t.type === "page" || t.type === "webview" || t.type === "app");
     const tabsBefore = pages.length;
     const seenUrls = new Set();
     let closedDuplicates = 0;
-    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+    const activeTargetId = sessionRegistry.getActive(getConfigAgentId(config), appName)?.targetId;
     for (const page of pages) {
         if (page.id === activeTargetId) {
             seenUrls.add(page.url);
@@ -240,17 +256,17 @@ export async function WeavetabConsolidate(config) {
         }
     }
     const afterTargets = await CDP.List({ host: "127.0.0.1", port });
-    const tabsAfter = afterTargets.filter((t) => t.type === "page").length;
+    const tabsAfter = afterTargets.filter((t) => t.type === "page" || t.type === "webview" || t.type === "app").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);
+export async function WeavetabHeal(config, appName) {
+    const port = resolvePort(config, appName);
     const targets = await CDP.List({ host: "127.0.0.1", port });
-    const pages = targets.filter((t) => t.type === "page");
+    const pages = targets.filter((t) => t.type === "page" || t.type === "webview" || t.type === "app");
     let healed = 0;
     const healthSummary = {};
     for (const page of pages) {
@@ -269,7 +285,7 @@ export async function WeavetabHeal(config) {
             continue;
         }
         try {
-            const client = await connectToTab(page.id);
+            const client = await connectToTab(page.id, undefined, undefined, undefined, appName);
             const { result } = await client.session.Runtime.evaluate({
                 expression: `document.readyState`,
                 returnByValue: true,
@@ -292,10 +308,10 @@ export async function WeavetabHeal(config) {
     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);
+export async function weaveWindowList(config, appName) {
+    const port = resolvePort(config, appName);
     const targets = await CDP.List({ host: "127.0.0.1", port });
-    const pages = targets.filter((t) => t.type === "page");
+    const pages = targets.filter((t) => t.type === "page" || t.type === "webview" || t.type === "app");
     // Group by process — each unique window has its own set of tabs
     // We approximate via CDP Target.getTargets windowId if available
     const windows = [];
@@ -307,7 +323,7 @@ export async function weaveWindowList(config) {
                 const { windowId, bounds } = await session.Browser.getWindowForTarget({ targetId: page.id });
                 if (!seenWindowIds.has(windowId)) {
                     seenWindowIds.add(windowId);
-                    const activeId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId;
+                    const activeId = sessionRegistry.getActive(getConfigAgentId(config), appName)?.targetId;
                     windows.push({
                         windowId,
                         state: bounds.windowState || "normal",
@@ -324,12 +340,12 @@ export async function weaveWindowList(config) {
     }
     return { windows };
 }
-export async function weaveFocusWindow(windowId, config) {
-    const port = resolvePort(config);
+export async function weaveFocusWindow(windowId, config, appName) {
+    const port = resolvePort(config, appName);
     const targets = await CDP.List({ host: "127.0.0.1", port });
-    const page = targets.find((t) => t.type === "page");
+    const page = targets.find((t) => t.type === "page" || t.type === "webview" || t.type === "app");
     if (!page)
-        throw new Error("No page target found to focus window");
+        throw new Error("No page or window 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" } });

package/dist/tools/thought.d.ts

@@ -2,6 +2,8 @@ import CDP from "chrome-remote-interface";
 export interface ThoughtOptions {
     action: "feedback" | "question";
     message: string;
+    anchor?: string;
+    style?: "observation" | "decision" | "warning" | "question";
     input?: "sentence" | "paragraph";
     timeout?: number;
 }

package/dist/tools/thought.js

@@ -7,32 +7,31 @@ function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
 export async function browserThought(session, args) {
-    const { action, message, input, timeout } = args;
+    const { action, message, input, timeout, anchor, style } = 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
+        // Forward thought event to extension
         await sendToExtension(session, {
             type: 'WT_THOUGHT',
             text: message,
             kind: 'thought',
+            anchor,
+            style: style || 'observation',
+            action: 'feedback',
         }).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),
-            },
+            type: 'WT_THOUGHT',
+            text: message,
+            kind: 'question',
+            anchor,
+            style: style || 'question',
+            action: 'question',
+            input: input || "sentence",
+            timeout: Math.min((timeout || 20), 20),
         }).catch(() => { });
         const start = Date.now();
         while (Date.now() - start < QUESTION_TIMEOUT_MS + 5000) {

package/dist/tools/type.d.ts

@@ -48,6 +48,8 @@ export declare function detectFramework(session: CDP.Client): Promise<'react' |
 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;
+    target?: string;
+    selector?: string;
     label?: string;
     intent?: string;
     backendNodeId?: number;