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

package/dist/cdp/connector.js

@@ -7,9 +7,9 @@ import { logDebug } from "../audit/logger.js";
  */
 import CDP from "chrome-remote-interface";
 import { blockStorageAccess } from "../security/guard.js";
-import { launchWithBridge, injectStealthScript } from "./bridge.js";
+import { launchWithBridge, launchElectronApp, injectStealthScript } from "./bridge.js";
 import { setupOverlay, ensureVisualLayer } from "../overlay/injector.js";
-import { onConfigChange, saveConfig, loadConfigSync, getCachedConfig, getConfigAgentId, getConfigCookies, getConfigProfileDir, getConfigMode } from "../config/loader.js";
+import { onConfigChange, saveConfig, loadConfigSync, getCachedConfig, getConfigAgentId, getConfigCookies, getConfigProfileDir, getConfigMode, getElectronAppConfig, getConfigExtension } from "../config/loader.js";
 import { sessionRegistry } from "../state/session.js";
 import { initConsoleBuffering } from "../tools/console.js";
 import { registerMutationListener, clearTabCache } from "../state/cache.js";
@@ -95,12 +95,21 @@ async function waitForPageReady(session) {
     });
 }
 // ─── Session init (overlay + re-injection) ───────────────────────────────────
-async function initSession(session, targetId, port, config) {
+async function initSession(session, targetId, port, config, isElectron) {
     initDialogHandler(session);
     // Initialize Omni-Context Broker for iframes
     const { initOmniBroker } = await import("./omni_broker.js");
     await initOmniBroker(session, targetId, port);
-    if (activeEngine === "chromium") {
+    if (isElectron) {
+        // Electron desktop app initialization
+        try {
+            await session.Page.addScriptToEvaluateOnNewDocument({ source: WT_REGISTRY_INIT_EXPR });
+        }
+        catch { /* non-fatal */ }
+        // Direct DOM minimal overlay injection without Chrome Extension
+        await ensureVisualLayer(session, config);
+    }
+    else if (activeEngine === "chromium") {
         // Only block cookies/storage when cookies mode is disabled
         if (!getConfigCookies(config)) {
             await blockStorageAccess(session);
@@ -142,7 +151,7 @@ async function initSession(session, targetId, port, config) {
         clearTabCache(targetId);
         // Invalidate URC on navigation — elements from the old page are stale
         urcInvalidate(targetId);
-        if (activeEngine === "chromium") {
+        if (isElectron || activeEngine === "chromium") {
             try {
                 await waitForPageReady(session);
                 const cfg = getCachedConfig();
@@ -154,8 +163,8 @@ async function initSession(session, targetId, port, config) {
             catch { /* ignore */ }
         }
     });
-    // Diagnostic: verify extension content script loaded
-    if (activeEngine === "chromium") {
+    // Diagnostic: verify extension content script loaded (Standard browser only)
+    if (!isElectron && activeEngine === "chromium" && getConfigExtension(config) !== false) {
         try {
             // Check for multiple indicators that extension is loaded
             const { result: extCheck } = await session.Runtime.evaluate({
@@ -174,29 +183,12 @@ async function initSession(session, targetId, port, config) {
             else {
                 logDebug(`[Weavetab] [!] Extension content script NOT detected — HUD/overlay may not work`);
                 logDebug(`[Weavetab] [!] Try reloading page or check if extension loaded in browser://extensions`);
-                // Try to inject a basic error indicator into the page
-                try {
-                    await session.Runtime.evaluate({
-                        expression: `
-              (function() {
-                const div = document.createElement('div');
-                div.style.cssText = 'position:fixed;top:10px;right:10px;background:red;color:white;padding:10px;z-index:999999;font-family:sans-serif;font-size:14px;';
-                div.textContent = 'WeaveTab Extension Not Loaded';
-                document.body.appendChild(div);
-                setTimeout(() => div.remove(), 5000);
-              })()
-            `
-                    });
-                }
-                catch { /* ignore */ }
             }
         }
         catch (checkErr) {
             logDebug(`[Weavetab] [!] Extension health check failed: ${checkErr}`);
         }
-    }
-    // Push config + initial idle state to extension right away (Chrome only)
-    if (activeEngine === "chromium") {
+        // Push config + initial idle state to extension right away (Chrome only)
         const { sendToExtension } = await import("../cdp/helpers.js");
         sendToExtension(session, {
             type: 'Weavetab_CONFIG',
@@ -207,8 +199,7 @@ async function initSession(session, targetId, port, config) {
             state: 'idle',
         }).catch(() => { });
     }
-    // Analytics ping every 5s — stored per-tab so each interval can be
-    // independently cancelled when the tab closes or cleanupAll() is called.
+    // Analytics ping every 30s
     const sessionStartTime = Date.now();
     const analyticsInterval = setInterval(async () => {
         try {
@@ -225,34 +216,135 @@ async function initSession(session, targetId, port, config) {
             }).catch(() => { });
         }
         catch { /* ignore */ }
-    }, 30_000); // 30s interval — reduced from 5s to cut idle CDP overhead (6 round-trips/min → 1)
-    // Register in the per-tab map so cleanupAll() and the session-close handler can
-    // cancel it without relying on a single overwriteable global slot.
+    }, 30_000);
     analyticsIntervals.set(targetId, analyticsInterval);
-    // unref() so this polling interval does not pin the Node.js event loop.
-    // An orphaned MCP process (IDE disconnected, browser closed) would otherwise
-    // stay alive indefinitely due to this 30s interval firing forever.
     analyticsInterval.unref();
 }
 // ─── Main connection entry point ──────────────────────────────────────────────
-export async function getOrConnect(config) {
-    if (getConfigMode(config) === "attach") {
+export async function getOrConnect(config, targetApp) {
+    if (getConfigMode(config) === "attach" && !targetApp) {
         throw new Error("[!] Attach mode (connect to your real browser) coming soon. Use session mode for now.");
     }
-    const activeClient = sessionRegistry.getActive(getConfigAgentId(config));
+    // 1. Check existing active session for this agent & app
+    const activeClient = sessionRegistry.getActive(getConfigAgentId(config), targetApp);
     if (activeClient) {
         try {
             await activeClient.session.Browser.getVersion();
             return activeClient;
         }
         catch {
-            logDebug("[Weavetab CDP] Connection lost. Reconnecting...");
+            logDebug(`[Weavetab CDP] Connection lost for ${targetApp || "browser"}. Reconnecting...`);
             clearProfileVerificationCache(activeClient.targetId);
             sessionRegistry.unregister(activeClient.targetId);
         }
     }
-    const releaseMutex = await acquireMutex();
+    const releaseMutex = await acquireMutex(targetApp);
     try {
+        if (targetApp) {
+            // ──────────────── ELECTRON APP CONNECTION FLOW ────────────────
+            const appCfg = getElectronAppConfig(targetApp, config);
+            if (!appCfg) {
+                throw new Error(`[Weavetab] ✗ Electron app "${targetApp}" is not configured in config.json.\n` +
+                    `  Please add an entry under "electron": { "${targetApp}": "C:\\\\path\\\\to\\\\app.exe" } in your config.`);
+            }
+            let port = null;
+            const sessionLock = readLock(targetApp);
+            if (sessionLock && sessionLock.mode === "session") {
+                if (isLockPending(sessionLock)) {
+                    logDebug(`[Weavetab] Launch in progress for ${targetApp} by PID ${sessionLock.pid}. Waiting up to 5s...`);
+                    for (let i = 0; i < 5; i++) {
+                        await new Promise(r => setTimeout(r, 1000));
+                        const updatedLock = readLock(targetApp);
+                        if (!updatedLock || !isLockPending(updatedLock))
+                            break;
+                    }
+                }
+                const freshLock = readLock(targetApp);
+                if (freshLock && (await isLockValid(freshLock))) {
+                    port = freshLock.port;
+                }
+                else {
+                    clearLock(targetApp);
+                }
+            }
+            let targets = [];
+            if (port) {
+                try {
+                    targets = await withCDPTimeout(CDP.List({ host: "127.0.0.1", port }), 3000, "CDP.List existing Electron");
+                }
+                catch {
+                    port = null;
+                }
+            }
+            if (!port || targets.length === 0) {
+                logDebug(`[Weavetab CDP] Launching Electron app ${targetApp}...`);
+                const launchResult = await launchElectronApp(targetApp, config);
+                port = launchResult.port;
+                // Poll for target window availability (Electron may take up to 2-3s to render initial window)
+                for (let retry = 0; retry < 10; retry++) {
+                    try {
+                        targets = await withCDPTimeout(CDP.List({ host: "127.0.0.1", port }), 2000, "CDP.List Electron retry");
+                        if (targets.length > 0)
+                            break;
+                    }
+                    catch { /* wait */ }
+                    await new Promise(r => setTimeout(r, 500));
+                }
+            }
+            let pageTarget = targets.find(t => t.type === "page" || t.type === "webview" || t.type === "app") ?? targets[0];
+            if (!pageTarget) {
+                throw new Error(`[Weavetab] ✗ No window or webview target found in Electron app "${targetApp}".`);
+            }
+            const targetId = pageTarget.id || pageTarget.targetId;
+            const session = await withCDPTimeout(CDP({ host: "127.0.0.1", port, target: targetId }), 5000, "CDP connect Electron target");
+            session.on("close", () => {
+                logDebug(`[Weavetab CDP] Electron session WebSocket closed (${targetApp}) — unregistering.`);
+                const iv = analyticsIntervals.get(targetId);
+                if (iv) {
+                    clearInterval(iv);
+                    analyticsIntervals.delete(targetId);
+                }
+                clearProfileVerificationCache(targetId);
+                import("./omni_broker.js").then(m => m.cleanupOmniBroker(targetId)).catch(() => { });
+                import("../tools/network_intercept.js").then(m => m.cleanupNetworkIntercept(session)).catch(() => { });
+                sessionRegistry.unregister(targetId);
+            });
+            session.on("error", (err) => {
+                logDebug(`[Weavetab CDP] Electron session WebSocket error (${targetApp}):`, err?.message ?? err);
+            });
+            // Validate connection health
+            try {
+                await session.Browser.getVersion();
+            }
+            catch {
+                throw new Error("Failed health check: CDP session connected to Electron app but getVersion failed.");
+            }
+            await Promise.all([
+                session.Accessibility.enable(),
+                session.DOM.enable(),
+                session.Page.enable(),
+                session.Runtime.enable(),
+                session.Network.enable().catch(() => { }),
+                session.Performance.enable().catch(() => { })
+            ]);
+            await wireUiConfigBinding(session);
+            await initSession(session, targetId, port, config, true);
+            await session.Target.setDiscoverTargets({ discover: true }).catch(() => { });
+            logDebug(`[Weavetab CDP] [OK] Active Electron target: ${pageTarget.title || pageTarget.url || targetApp}`);
+            const client = {
+                session,
+                targetId,
+                url: pageTarget.url || "",
+                title: pageTarget.title || targetApp,
+                overlayInstalled: false,
+                agentId: getConfigAgentId(config),
+                appName: targetApp,
+                isElectron: true,
+            };
+            sessionRegistry.register(targetId, client);
+            return client;
+        }
+        // ──────────────── STANDARD WEB BROWSER FLOW ────────────────
         const sessionLock = readLock();
         if (sessionLock && sessionLock.mode === "session") {
             if (isLockPending(sessionLock)) {
@@ -437,7 +529,7 @@ export async function getOrConnect(config) {
             if (activatedId) {
                 const client = sessionRegistry.getAll().find(c => c.targetId === activatedId);
                 if (client) {
-                    sessionRegistry.setActive(activatedId, client.agentId);
+                    sessionRegistry.setActive(activatedId, client.agentId, client.appName);
                 }
             }
         });
@@ -491,28 +583,34 @@ export async function getOrConnect(config) {
         await releaseMutex();
     }
 }
-export async function getTabList(agentId) {
+export async function getTabList(agentId, targetApp) {
     const config = getCachedConfig();
-    // Validate the lock before blindly connecting (same two-factor check that
-    // getOrConnect() performs). A stale lock after a server restart would otherwise
-    // produce raw ECONNREFUSED.
-    let port = actualPort;
-    if (!port) {
-        const lock = readLock();
-        if (lock && lock.mode === "session") {
-            const valid = await isLockValid(lock);
-            if (valid) {
-                port = lock.port;
-            }
-            else {
-                logDebug("[Weavetab CDP] getTabList: stale lock detected — clearing.");
-                clearLock();
-                port = null;
+    let port = null;
+    if (targetApp) {
+        const lock = readLock(targetApp);
+        if (lock && (await isLockValid(lock))) {
+            port = lock.port;
+        }
+    }
+    else {
+        port = actualPort;
+        if (!port) {
+            const lock = readLock();
+            if (lock && lock.mode === "session") {
+                const valid = await isLockValid(lock);
+                if (valid) {
+                    port = lock.port;
+                }
+                else {
+                    logDebug("[Weavetab CDP] getTabList: stale lock detected — clearing.");
+                    clearLock();
+                    port = null;
+                }
             }
         }
     }
     if (!port)
-        throw new Error("[!] No active browser session. Run browser_go first.");
+        throw new Error(`[!] No active ${targetApp ? targetApp : "browser"} session. Run browser_go or launch app first.`);
     try {
         const metaSession = await withCDPTimeout(CDP({ host: "127.0.0.1", port }), 5000, "getTabList CDP");
         const { targetInfos } = await withCDPTimeout(metaSession.Target.getTargets(), 5000, "getTabList getTargets");
@@ -520,21 +618,21 @@ export async function getTabList(agentId) {
         const aid = agentId || getConfigAgentId(config);
         const bctxId = sessionRegistry.getBrowserContextIdForAgent(aid);
         return targetInfos
-            .filter(t => t.type === "page" && (!bctxId || t.browserContextId === bctxId))
+            .filter(t => (t.type === "page" || t.type === "webview" || t.type === "app" || t.type === "other" || t.type === "iframe") && (!bctxId || t.browserContextId === bctxId))
             .map(t => ({
             id: t.targetId,
-            title: t.title,
+            title: t.title || t.url || t.type,
             url: t.url,
             type: t.type,
         }));
     }
     catch {
-        throw new Error(`[!] Weavetab cannot reach browser on port ${port}.`);
+        throw new Error(`[!] Weavetab cannot reach ${targetApp ? targetApp : "browser"} on port ${port}.`);
     }
 }
 // Only allow the UI to update cosmetic/dev settings via the binding.
 // Never allow overwriting security-critical fields (role, browserPath, block, allow, profileDir, etc.).
-const UI_ALLOWED_FIELDS = new Set(["devMode", "visuals", "darkMode"]);
+const UI_ALLOWED_FIELDS = new Set(["devMode", "extension"]);
 async function wireUiConfigBinding(session) {
     try {
         await session.Runtime.addBinding({ name: "__wt_save_ui_config" });
@@ -562,21 +660,38 @@ async function wireUiConfigBinding(session) {
     }
     catch { /* already bound */ }
 }
-export async function connectToTab(targetId, port, agentId, browserContextId) {
+export async function connectToTab(targetId, port, agentId, browserContextId, appName) {
     const existing = sessionRegistry.getAll().find(c => c.targetId === targetId);
     if (existing)
         return existing;
-    const lock = readLock();
-    const p = port || actualPort || lock?.port;
+    const lock = readLock(appName);
+    const p = port || (appName ? lock?.port : (actualPort || lock?.port));
     if (!p)
-        throw new Error("[!] No active browser session. Run browser_go first.");
-    const targets = await withCDPTimeout(CDP.List({ host: "127.0.0.1", port: p }), 5000, "connectToTab CDP.List");
-    const t = targets.find(t => t.id === targetId);
-    if (!t)
-        throw new Error("Tab not found");
+        throw new Error(`[!] No active ${appName || "browser"} session. Run browser_go first.`);
+    let t = null;
+    try {
+        const targets = await withCDPTimeout(CDP.List({ host: "127.0.0.1", port: p }), 3000, "connectToTab CDP.List");
+        t = targets.find((item) => (item.id || item.targetId) === targetId);
+    }
+    catch { }
+    if (!t) {
+        try {
+            const metaSession = await withCDPTimeout(CDP({ host: "127.0.0.1", port: p }), 3000, "connectToTab meta CDP");
+            const { targetInfos } = await withCDPTimeout(metaSession.Target.getTargets(), 3000, "connectToTab meta getTargets");
+            await metaSession.close();
+            const ti = targetInfos.find(item => item.targetId === targetId);
+            if (ti) {
+                t = { id: ti.targetId, targetId: ti.targetId, url: ti.url, title: ti.title, type: ti.type };
+            }
+        }
+        catch { }
+    }
+    if (!t) {
+        t = { id: targetId, targetId, url: "", title: appName || "Tab", type: "page" };
+    }
     const session = await withCDPTimeout(CDP({ host: "127.0.0.1", port: p, target: targetId }), 5000, "connectToTab CDP");
     session.on("close", () => {
-        logDebug("[Weavetab CDP] connectToTab session closed — unregistering.");
+        logDebug(`[Weavetab CDP] connectToTab session closed (${appName || "browser"}) — unregistering.`);
         // Cancel this tab's analytics interval so it doesn't outlive the session
         const iv = analyticsIntervals.get(targetId);
         if (iv) {
@@ -589,7 +704,7 @@ export async function connectToTab(targetId, port, agentId, browserContextId) {
         sessionRegistry.unregister(targetId);
     });
     session.on("error", (err) => {
-        logDebug("[Weavetab CDP] connectToTab session error:", err?.message ?? err);
+        logDebug(`[Weavetab CDP] connectToTab session error (${appName || "browser"}):`, err?.message ?? err);
     });
     await Promise.all([
         session.Accessibility.enable(),
@@ -601,7 +716,7 @@ export async function connectToTab(targetId, port, agentId, browserContextId) {
     ]);
     await wireUiConfigBinding(session);
     const currentConfig = getCachedConfig();
-    await initSession(session, targetId, p, currentConfig);
+    await initSession(session, targetId, p, currentConfig, !!appName);
     // NOTE: initSession() already installs a frameNavigated handler that handles
     // clearSnapshot, clearViewportCache, and ensureVisualLayer. Do NOT add a second
     // one here — it would double the CDP work on every navigation.
@@ -614,6 +729,8 @@ export async function connectToTab(targetId, port, agentId, browserContextId) {
         overlayInstalled: false,
         agentId: actualAgentId,
         browserContextId,
+        appName,
+        isElectron: !!appName,
     };
     sessionRegistry.register(targetId, client);
     return client;

package/dist/cdp/lock.d.ts

@@ -4,6 +4,7 @@ export interface LockData {
     profileDir: string;
     browserPath: string;
     mode: "session" | "attach";
+    appName?: string;
     pending?: boolean;
     timestamp?: number;
     fingerprint?: {
@@ -12,17 +13,19 @@ export interface LockData {
         cdpVersion?: string;
     };
 }
-declare function acquireMutex(): Promise<() => Promise<void>>;
-export declare function writeLockSafe(data: LockData): Promise<void>;
-export declare function writeLock(data: LockData): Promise<void>;
-export declare function readLock(): LockData | null;
-export declare function clearLock(): void;
+export declare function getLockFilePath(appName?: string): string;
+export declare function getMutexFilePath(appName?: string): string;
+declare function acquireMutex(appName?: string): Promise<() => Promise<void>>;
+export declare function writeLockSafe(data: LockData, appName?: string): Promise<void>;
+export declare function writeLock(data: LockData, appName?: string): Promise<void>;
+export declare function readLock(appName?: string): LockData | null;
+export declare function clearLock(appName?: string): void;
 /**
  * Safe variant: only clears the lock if it was written by THIS process (process.pid).
  * Prevents a second MCP server instance from wiping the first instance's browser lock
  * during its retry loop, which would allow a race condition where two browsers spawn.
  */
-export declare function clearLockIfOwned(): void;
+export declare function clearLockIfOwned(appName?: string): void;
 export declare function isProcessRunning(pid: number): boolean;
 /**
  * Two-factor lock validation: PID alive AND port accepting TCP connections.

package/dist/cdp/lock.js

@@ -10,49 +10,56 @@ import * as path from "node:path";
 import * as os from "node:os";
 import * as net from "node:net";
 import { lock } from "proper-lockfile";
+import { sanitizeAppName } from "./profiles.js";
 const LOCK_DIR = path.join(os.homedir(), ".weavetab-system", "locks");
-const LOCK_FILE = path.join(LOCK_DIR, ".weavetab.lock");
-const MUTEX_FILE = path.join(LOCK_DIR, ".weavetab.lock.mutex");
-// ─── In-process serialization queue ──────────────────────────────────────────
-// When multiple MCP tool calls run in parallel inside the same Node process they
-// all race to acquireMutex() simultaneously. The OS-level proper-lockfile handles
-// cross-process contention, but within the same process concurrent callers share
-// the same lockfile handle and can trigger "Lock is already released" errors.
-// This queue serializes callers at the JS level before they touch the filesystem.
-let _inProcessMutexQueue = Promise.resolve();
-// Re-entrancy tracking. getOrConnect() acquires the mutex and then calls
-// launchWithBridge(), which internally calls writeLock() → acquireMutex()
-// again (nested). The serialization queue would block the nested call on the
-// outer slot, which only releases after the launch finishes — a self-deadlock.
-// Track how many regions this process currently holds and only touch the OS
-// file lock + queue slot on the outermost acquisition / release.
-let _heldDepth = 0;
-let _heldFileRelease = null;
-let _heldSlotResolve = null;
-async function acquireMutex() {
-    // Re-entrant fast path: this process already holds the mutex.
-    if (_heldDepth > 0) {
-        _heldDepth++;
+export function getLockFilePath(appName) {
+    if (appName && appName.trim()) {
+        return path.join(LOCK_DIR, `.weavetab.electron.${sanitizeAppName(appName)}.lock`);
+    }
+    return path.join(LOCK_DIR, ".weavetab.lock");
+}
+export function getMutexFilePath(appName) {
+    if (appName && appName.trim()) {
+        return path.join(LOCK_DIR, `.weavetab.electron.${sanitizeAppName(appName)}.lock.mutex`);
+    }
+    return path.join(LOCK_DIR, ".weavetab.lock.mutex");
+}
+// ─── In-process serialization queues per app/browser ──────────────────────────
+const _inProcessQueues = new Map();
+const _heldDepths = new Map();
+const _heldFileReleases = new Map();
+const _heldSlotResolves = new Map();
+function getTargetKey(appName) {
+    return appName && appName.trim() ? `electron:${sanitizeAppName(appName)}` : "browser";
+}
+async function acquireMutex(appName) {
+    const key = getTargetKey(appName);
+    const currentDepth = _heldDepths.get(key) ?? 0;
+    // Re-entrant fast path: this process already holds the mutex for this target.
+    if (currentDepth > 0) {
+        _heldDepths.set(key, currentDepth + 1);
         return async () => {
-            _heldDepth--;
+            const d = (_heldDepths.get(key) ?? 1) - 1;
+            _heldDepths.set(key, Math.max(0, d));
         };
     }
-    // Enqueue this caller — it will only proceed once all prior callers finish.
+    // Enqueue this caller for this specific key
     let resolveSlot;
     const slot = new Promise(resolve => { resolveSlot = resolve; });
-    const prevQueue = _inProcessMutexQueue;
-    _inProcessMutexQueue = _inProcessMutexQueue.then(() => slot);
-    await prevQueue; // Wait for all prior callers to fully release
+    const prevQueue = _inProcessQueues.get(key) ?? Promise.resolve();
+    _inProcessQueues.set(key, prevQueue.then(() => slot));
+    await prevQueue; // Wait for all prior callers for this key to fully release
     fs.mkdirSync(LOCK_DIR, { recursive: true });
-    if (!fs.existsSync(MUTEX_FILE)) {
+    const mutexFile = getMutexFilePath(appName);
+    if (!fs.existsSync(mutexFile)) {
         try {
-            fs.writeFileSync(MUTEX_FILE, String(process.pid), "utf-8");
+            fs.writeFileSync(mutexFile, String(process.pid), "utf-8");
         }
         catch { /* race/non-fatal */ }
     }
     let fileRelease = null;
     try {
-        fileRelease = await lock(MUTEX_FILE, {
+        fileRelease = await lock(mutexFile, {
             retries: {
                 retries: 25,
                 minTimeout: 200,
@@ -62,28 +69,29 @@ async function acquireMutex() {
         });
         // Write current PID to mutex file for diagnostics/HUD
         try {
-            fs.writeFileSync(MUTEX_FILE, String(process.pid), "utf-8");
+            fs.writeFileSync(mutexFile, String(process.pid), "utf-8");
         }
         catch { /* non-fatal */ }
     }
     catch (err) {
         resolveSlot(); // Unblock the queue even on failure
-        throw new Error(`[Weavetab] Could not acquire launch mutex after retries: ${err?.message || err}`);
+        throw new Error(`[Weavetab] Could not acquire launch mutex for ${key} after retries: ${err?.message || err}`);
     }
     // Mark this process as the current holder so nested calls skip the queue.
-    _heldDepth = 1;
-    _heldFileRelease = fileRelease;
-    _heldSlotResolve = resolveSlot;
+    _heldDepths.set(key, 1);
+    _heldFileReleases.set(key, fileRelease);
+    _heldSlotResolves.set(key, resolveSlot);
     // Return a release function that releases both the file lock and the in-process slot
     return async () => {
-        _heldDepth--;
-        if (_heldDepth > 0)
+        const d = (_heldDepths.get(key) ?? 1) - 1;
+        _heldDepths.set(key, Math.max(0, d));
+        if (d > 0)
             return; // nested regions still active
-        _heldDepth = 0;
-        const rel = _heldFileRelease;
-        const slotResolve = _heldSlotResolve;
-        _heldFileRelease = null;
-        _heldSlotResolve = null;
+        _heldDepths.delete(key);
+        const rel = _heldFileReleases.get(key);
+        const slotResolve = _heldSlotResolves.get(key);
+        _heldFileReleases.delete(key);
+        _heldSlotResolves.delete(key);
         try {
             if (rel)
                 await rel();
@@ -94,44 +102,49 @@ async function acquireMutex() {
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
-export async function writeLockSafe(data) {
-    const release = await acquireMutex();
+export async function writeLockSafe(data, appName) {
+    const targetApp = appName || data.appName;
+    const release = await acquireMutex(targetApp);
+    const lockFile = getLockFilePath(targetApp);
     try {
         fs.mkdirSync(LOCK_DIR, { recursive: true });
-        fs.writeFileSync(LOCK_FILE, JSON.stringify(data, null, 2), "utf-8");
+        fs.writeFileSync(lockFile, JSON.stringify(data, null, 2), "utf-8");
     }
     finally {
         await release();
     }
 }
-export async function writeLock(data) {
-    await writeLockSafe(data);
+export async function writeLock(data, appName) {
+    await writeLockSafe(data, appName);
 }
-export function readLock() {
-    if (!fs.existsSync(LOCK_FILE))
+export function readLock(appName) {
+    const lockFile = getLockFilePath(appName);
+    if (!fs.existsSync(lockFile))
         return null;
     try {
-        return JSON.parse(fs.readFileSync(LOCK_FILE, "utf-8"));
+        return JSON.parse(fs.readFileSync(lockFile, "utf-8"));
     }
     catch {
         return null;
     }
 }
-export function clearLock() {
+export function clearLock(appName) {
+    const lockFile = getLockFilePath(appName);
+    const mutexFile = getMutexFilePath(appName);
     try {
-        if (fs.existsSync(LOCK_FILE))
-            fs.unlinkSync(LOCK_FILE);
+        if (fs.existsSync(lockFile))
+            fs.unlinkSync(lockFile);
     }
     catch (e) {
         logDebug(`[Weavetab] [!] Failed to clear lock file: ${e}`);
     }
     try {
-        if (fs.existsSync(MUTEX_FILE))
-            fs.unlinkSync(MUTEX_FILE);
+        if (fs.existsSync(mutexFile))
+            fs.unlinkSync(mutexFile);
     }
     catch { /* ignore */ }
     try {
-        const lockDir = MUTEX_FILE + ".lock";
+        const lockDir = mutexFile + ".lock";
         if (fs.existsSync(lockDir))
             fs.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -142,14 +155,14 @@ export function clearLock() {
  * Prevents a second MCP server instance from wiping the first instance's browser lock
  * during its retry loop, which would allow a race condition where two browsers spawn.
  */
-export function clearLockIfOwned() {
+export function clearLockIfOwned(appName) {
     try {
-        const lock = readLock();
+        const lock = readLock(appName);
         if (!lock || lock.pid !== process.pid) {
             logDebug(`[Weavetab] clearLockIfOwned: skipping — lock owned by PID ${lock?.pid ?? 'none'}, this PID is ${process.pid}`);
             return;
         }
-        clearLock();
+        clearLock(appName);
     }
     catch (e) {
         logDebug(`[Weavetab] clearLockIfOwned error: ${e}`);

package/dist/cdp/omni_broker.d.ts

@@ -14,4 +14,5 @@ export declare function initOmniBroker(parentSession: CDP.Client, parentTargetId
  * Executes a CDP command across all known iframe contexts if it fails in the top-level context.
  */
 export declare function omniEvaluate(parentSession: CDP.Client, parentTargetId: string, expression: string, returnByValue?: boolean): Promise<any>;
+export declare function getOmniSessions(parentTargetId: string): Map<string, CDP.Client> | undefined;
 export declare function cleanupOmniBroker(parentTargetId: string): void;