@weavetab/mcp 2.5.0-beta.0

package/dist/cdp/extension.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Weavetab — cdp/extension.ts
+ * Extension detection and health-check layer.
+ * All extension-dependent tools should call requireExtension() before proceeding.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+/**
+ * Check whether the Weavetab extension is loaded in the current page.
+ * Uses DOM markers instead of JS globals because content scripts run in
+ * an ISOLATED world (MV3) — window.__Weavetab is invisible from MAIN world.
+ */
+export declare function isExtensionLoaded(session: CDP.Client): Promise<boolean>;
+/**
+ * Throws a clear, actionable error if the extension is not loaded.
+ */
+export declare function requireExtension(session: CDP.Client): Promise<void>;
+/**
+ * Full health check — which extension features are available.
+ */
+export declare function extensionHealth(session: CDP.Client): Promise<{
+    loaded: boolean;
+    version?: string;
+    features: string[];
+}>;
+/**
+ * Suppress all visual overlays/borders the extension draws on interactive elements.
+ * Call this before taking screenshots or when clean rendering is needed.
+ * Default behavior for browser_map — overlays should only appear via browser_highlight.
+ */
+export declare function suppressOverlays(session: CDP.Client): Promise<void>;
+/**
+ * Re-enable visual overlays for debugging purposes.
+ * Only call this if user explicitly passes show_overlays: true to browser_map.
+ */
+export declare function restoreOverlays(session: CDP.Client): Promise<void>;

package/dist/cdp/extension.js

@@ -0,0 +1,118 @@
+/**
+ * Check whether the Weavetab extension is loaded in the current page.
+ * Uses DOM markers instead of JS globals because content scripts run in
+ * an ISOLATED world (MV3) — window.__Weavetab is invisible from MAIN world.
+ */
+export async function isExtensionLoaded(session) {
+    try {
+        const { result } = await session.Runtime.evaluate({
+            expression: `!!(
+        document.getElementById('wt-extension-marker') ||
+        document.querySelector('weavetab-host') ||
+        document.querySelector('[data-wt-internal]') ||
+        document.getElementById('__Weavetab_cursor_host') ||
+        document.getElementById('wt-ui-styles')
+      )`,
+            returnByValue: true,
+        });
+        return result?.value === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Throws a clear, actionable error if the extension is not loaded.
+ */
+export async function requireExtension(session) {
+    let loaded = await isExtensionLoaded(session);
+    if (!loaded) {
+        try {
+            // Auto-recovery: if marker is missing, the page might be in a broken state.
+            // Attempt a single reload before failing the tool call.
+            await session.Page.reload({ ignoreCache: false });
+            await new Promise(r => setTimeout(r, 2000)); // wait for content script injection
+            loaded = await isExtensionLoaded(session);
+        }
+        catch { /* ignore reload errors */ }
+    }
+    if (!loaded) {
+        throw new Error("[!] Weavetab Extension not detected on this page. " +
+            "Make sure the extension is installed (from ext-dist/) and the page has been loaded/refreshed. " +
+            "Some tools require the extension for full functionality.");
+    }
+}
+/**
+ * Full health check — which extension features are available.
+ */
+export async function extensionHealth(session) {
+    try {
+        // Use DOM markers + fallback JS checks via postMessage bridge
+        const loaded = await isExtensionLoaded(session);
+        const { result } = await session.Runtime.evaluate({
+            expression: `(function() {
+        const features = [];
+        if (document.querySelector('weavetab-host') || document.getElementById('__Weavetab_cursor_host')) features.push('cursor');
+        if (document.querySelector('[data-wt-internal]') || document.getElementById('wt-ui-styles')) features.push('styles');
+        if (document.querySelector('.wt-bubble')) features.push('bubble');
+        if (document.getElementById('wt-plan-panel')) features.push('plan');
+        return JSON.stringify({
+          loaded: ${loaded},
+          features
+        });
+      })()`,
+            returnByValue: true,
+        });
+        if (result?.value) {
+            return JSON.parse(result.value);
+        }
+    }
+    catch { /* ignore */ }
+    return { loaded: false, features: [] };
+}
+/**
+ * Suppress all visual overlays/borders the extension draws on interactive elements.
+ * Call this before taking screenshots or when clean rendering is needed.
+ * Default behavior for browser_map — overlays should only appear via browser_highlight.
+ */
+export async function suppressOverlays(session) {
+    try {
+        await session.Runtime.evaluate({
+            expression: `(function() {
+        // Remove any existing Weavetab overlay elements
+        document.querySelectorAll('[data-Weavetab-overlay]').forEach(el => el.remove());
+        // Hide fallback visual elements
+        var sr = document.getElementById('Weavetab-root');
+        if (sr && sr.shadowRoot) {
+          var els = sr.shadowRoot.querySelectorAll('#wt-fallback-cursor, #wt-fallback-hud, #wt-fallback-thought');
+          els.forEach(function(el){ el.style.display = 'none'; });
+        }
+        // Post a message for the content script (isolated world)
+        window.postMessage({ type: 'Weavetab_SUPPRESS_VISUALS', suppress: true }, '*');
+      })()`,
+            returnByValue: false,
+        });
+    }
+    catch { /* non-fatal */ }
+}
+/**
+ * Re-enable visual overlays for debugging purposes.
+ * Only call this if user explicitly passes show_overlays: true to browser_map.
+ */
+export async function restoreOverlays(session) {
+    try {
+        await session.Runtime.evaluate({
+            expression: `(function() {
+        // Restore fallback visual elements
+        var sr = document.getElementById('Weavetab-root');
+        if (sr && sr.shadowRoot) {
+          var els = sr.shadowRoot.querySelectorAll('#wt-fallback-cursor, #wt-fallback-hud, #wt-fallback-thought');
+          els.forEach(function(el){ el.style.display = ''; });
+        }
+        window.postMessage({ type: 'Weavetab_SUPPRESS_VISUALS', suppress: false }, '*');
+      })()`,
+            returnByValue: false,
+        });
+    }
+    catch { /* non-fatal */ }
+}

package/dist/cdp/finder.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cdp/finder.js

@@ -0,0 +1,2 @@
+export {};
+// File deprecated and replaced by bridge.ts

package/dist/cdp/helpers.d.ts

@@ -0,0 +1,11 @@
+import CDP from "chrome-remote-interface";
+/**
+ * sendToExtension is the only bridge to communicate from Node (CLI)
+ * to the Weavetab Chrome Extension via CDP executeScript.
+ * Messages are queued and batched with backpressure.
+ * Returns true if the message was queued, false if dropped.
+ */
+export declare function sendToExtension(session: CDP.Client, message: object): Promise<boolean>;
+export declare function getFromExtension<T = any>(session: CDP.Client, message: object, retries?: number): Promise<T | null>;
+export declare function hideWeaveTabOverlay(session: CDP.Client): Promise<void>;
+export declare function restoreWeaveTabOverlay(session: CDP.Client): Promise<void>;

package/dist/cdp/helpers.js

@@ -0,0 +1,195 @@
+import { logDebug } from "../audit/logger.js";
+const MAX_QUEUE_SIZE = 50;
+const BATCH_INTERVAL_MS = 10; // Reduced from 20ms for faster message delivery
+const messageQueues = new Map();
+const queueTimers = new Map();
+async function drainQueue(session, targetId) {
+    const queue = messageQueues.get(targetId);
+    if (!queue || queue.length === 0)
+        return;
+    const batch = queue.splice(0, Math.min(queue.length, 10));
+    const messages = batch.map((q, i) => {
+        const msg = q.message;
+        // Add dedup _id using queue entry's id (unique) so content.js __wt_processedMsgIds works
+        if (typeof msg === 'object' && msg !== null) {
+            msg._id = q.id + (i > 0 ? '-' + i : '');
+        }
+        return msg;
+    });
+    try {
+        const msgData = JSON.stringify(messages.length === 1 ? messages[0] : messages);
+        await session.Runtime.evaluate({
+            expression: `
+        try {
+          window.postMessage({ type: 'Weavetab-msg-in', data: ${msgData} }, '*');
+        } catch(e) {}
+      `
+        });
+        batch.forEach(q => q.resolve(true));
+    }
+    catch (e) {
+        logDebug(`[Weavetab] Failed to send batch (${batch.length} msgs)`, e);
+        batch.forEach(q => {
+            q.attempts++;
+            if (q.attempts < 3) {
+                queue.push(q); // re-queue for retry
+            }
+            else {
+                q.resolve(false);
+            }
+        });
+    }
+    // Schedule next drain if messages remain
+    if (queue.length > 0) {
+        const timer = setTimeout(() => drainQueue(session, targetId), BATCH_INTERVAL_MS);
+        queueTimers.set(targetId, timer);
+    }
+    else {
+        const t = queueTimers.get(targetId);
+        if (t) {
+            clearTimeout(t);
+            queueTimers.delete(targetId);
+        }
+    }
+}
+function enqueueMessage(session, targetId, message) {
+    return new Promise((resolve) => {
+        let queue = messageQueues.get(targetId);
+        if (!queue) {
+            queue = [];
+            messageQueues.set(targetId, queue);
+        }
+        // Backpressure: if queue is full, reject oldest message to make room
+        if (queue.length >= MAX_QUEUE_SIZE) {
+            const dropped = queue.shift();
+            if (dropped) {
+                logDebug(`[Weavetab] Backpressure: dropping oldest message (${dropped.id})`);
+                dropped.resolve(false);
+            }
+        }
+        const qMsg = {
+            id: Math.random().toString(36).slice(2, 10),
+            message,
+            resolve,
+            timestamp: Date.now(),
+            attempts: 0,
+        };
+        queue.push(qMsg);
+        // Start drain timer if not already running
+        if (!queueTimers.has(targetId)) {
+            const timer = setTimeout(() => drainQueue(session, targetId), BATCH_INTERVAL_MS);
+            queueTimers.set(targetId, timer);
+        }
+    });
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function getTargetId(session) {
+    return session._targetId || session.targetId || "default";
+}
+/**
+ * sendToExtension is the only bridge to communicate from Node (CLI)
+ * to the Weavetab Chrome Extension via CDP executeScript.
+ * Messages are queued and batched with backpressure.
+ * Returns true if the message was queued, false if dropped.
+ */
+export async function sendToExtension(session, message) {
+    try {
+        const targetId = getTargetId(session);
+        return await enqueueMessage(session, targetId, message);
+    }
+    catch (e) {
+        logDebug("[Weavetab] Failed to sendToExtension", e);
+        return false;
+    }
+}
+export async function getFromExtension(session, message, retries = 0) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            const { result } = await session.Runtime.evaluate({
+                expression: `new Promise((resolve) => {
+          try {
+            const id = Math.random().toString();
+            const listener = (e) => {
+              if (e.detail && e.detail.id === id) {
+                window.removeEventListener('Weavetab-msg-out', listener);
+                resolve(JSON.stringify(e.detail.data));
+              }
+            };
+            window.addEventListener('Weavetab-msg-out', listener);
+            window.dispatchEvent(new CustomEvent('Weavetab-msg-in', { detail: Object.assign({}, ${JSON.stringify(message)}, { id }) }));
+            
+            // Fallback timeout — 100ms fail-fast (reduced from 150ms)
+            setTimeout(() => {
+              window.removeEventListener('Weavetab-msg-out', listener);
+              resolve("null");
+            }, 100);
+          } catch (e) {
+            resolve("null");
+          }
+        })`,
+                awaitPromise: true,
+                returnByValue: true
+            });
+            if (result && result.value && result.value !== "null") {
+                return JSON.parse(result.value);
+            }
+            // Got null — if we have retries left, try again
+            if (attempt < retries) {
+                logDebug(`[Weavetab] Extension did not respond (attempt ${attempt + 1}/${retries + 1}), retrying...`);
+                continue;
+            }
+        }
+        catch (e) {
+            if (attempt < retries) {
+                logDebug(`[Weavetab] getFromExtension error (attempt ${attempt + 1}/${retries + 1}): ${e instanceof Error ? e.message : e}`);
+                continue;
+            }
+            logDebug("[Weavetab] Failed to getFromExtension after retries", e);
+        }
+    }
+    return null;
+}
+export async function hideWeaveTabOverlay(session) {
+    await session.Runtime.evaluate({
+        expression: `(function(){
+      var existing = document.getElementById('__wt_hide_overlay_styles');
+      if (existing) return; // already hidden
+      var style = document.createElement('style');
+      style.id = '__wt_hide_overlay_styles';
+      // Cover ALL Weavetab overlay elements so they never appear in screenshots/PDFs/snapshots:
+      //  - [id^="Weavetab-"]    : Weavetab-root shadow host, any legacy Weavetab- elements
+      //  - [id^="__Weavetab_"]  : __Weavetab_cursor_host (ghost cursor)
+      //  - [id^="wt-"]          : wt-* legacy element IDs
+      //  - [data-wt-internal]   : HUD iframe host (closed shadow DOM mount)
+      //  - [data-wt-ignore]     : any element flagged as agent-invisible
+      //  - .wt-bubble           : thought bubble / action text popups
+      //  - #__wt_ask_bridge     : question input bridge element
+      //  - #wt-plan-dashboard   : mission plan dashboard
+      //  - #wt-debug-overlay    : debug overlay panel
+      //  - #wt-main-container   : WeaveTab OS panel (todos + chat)
+      style.textContent = [
+        '[id^="Weavetab-"]',
+        '[id^="__Weavetab_"]',
+        '[id^="wt-"]',
+        '[data-wt-internal]',
+        '[data-wt-ignore]',
+        '.wt-bubble',
+        '#__wt_ask_bridge',
+        '#wt-plan-dashboard',
+        '#wt-debug-overlay',
+        '#wt-main-container',
+      ].join(', ') + ' { display: none !important; visibility: hidden !important; opacity: 0 !important; }';
+      document.head.appendChild(style);
+    })()`,
+        returnByValue: false,
+    }).catch(() => { });
+}
+export async function restoreWeaveTabOverlay(session) {
+    await session.Runtime.evaluate({
+        expression: `(function(){
+      var style = document.getElementById('__wt_hide_overlay_styles');
+      if (style) style.remove();
+    })()`,
+        returnByValue: false,
+    }).catch(() => { });
+}

package/dist/cdp/label_cache.d.ts

@@ -0,0 +1,12 @@
+declare class LabelCache {
+    private maxEntries;
+    private cache;
+    constructor(maxEntries?: number);
+    private getKey;
+    get(url: string, label: string): string | null;
+    set(url: string, label: string, ref: string): void;
+    invalidate(url: string): void;
+    private evict;
+}
+export declare const labelCache: LabelCache;
+export {};

package/dist/cdp/label_cache.js

@@ -0,0 +1,51 @@
+// src/cdp/label_cache.ts
+// In-memory LRU cache to map labels to Ref IDs to speed up repeated browser_click calls
+class LabelCache {
+    maxEntries;
+    cache;
+    constructor(maxEntries = 200) {
+        this.maxEntries = maxEntries;
+        this.cache = new Map();
+    }
+    getKey(url, label) {
+        return `${url}:::${label}`;
+    }
+    get(url, label) {
+        const key = this.getKey(url, label);
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        // Update timestamp for LRU
+        entry.timestamp = Date.now();
+        return entry.ref;
+    }
+    set(url, label, ref) {
+        const key = this.getKey(url, label);
+        if (this.cache.size >= this.maxEntries) {
+            this.evict();
+        }
+        this.cache.set(key, { ref, timestamp: Date.now() });
+    }
+    invalidate(url) {
+        const prefix = `${url}:::`;
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    evict() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+}
+export const labelCache = new LabelCache();

package/dist/cdp/lock.d.ts

@@ -0,0 +1,33 @@
+export interface LockData {
+    pid?: number;
+    port: number;
+    profileDir: string;
+    browserPath: string;
+    mode: "session" | "attach";
+    pending?: boolean;
+    timestamp?: number;
+    fingerprint?: {
+        launchTimestamp: number;
+        userAgent?: string;
+        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;
+/**
+ * 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 isProcessRunning(pid: number): boolean;
+/**
+ * Two-factor lock validation: PID alive AND port accepting TCP connections.
+ * Prevents PID-reuse false-positives after a crash.
+ */
+export declare function isLockValid(lock: LockData): Promise<boolean>;
+export declare function isLockPending(lock: LockData): boolean;
+export { acquireMutex };

package/dist/cdp/lock.js

@@ -0,0 +1,206 @@
+import { logDebug } from "../audit/logger.js";
+/**
+ * Weavetab — cdp/lock.ts
+ * Crash-safe, mutex-protected lock file for browser process tracking.
+ * Uses proper-lockfile for OS-level advisory locking to prevent race conditions.
+ * Weavetab by fy2ne
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as net from "node:net";
+import { lock } from "proper-lockfile";
+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++;
+        return async () => {
+            _heldDepth--;
+        };
+    }
+    // Enqueue this caller — it will only proceed once all prior callers finish.
+    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
+    fs.mkdirSync(LOCK_DIR, { recursive: true });
+    if (!fs.existsSync(MUTEX_FILE)) {
+        try {
+            fs.writeFileSync(MUTEX_FILE, String(process.pid), "utf-8");
+        }
+        catch { /* race/non-fatal */ }
+    }
+    let fileRelease = null;
+    try {
+        fileRelease = await lock(MUTEX_FILE, {
+            retries: {
+                retries: 25,
+                minTimeout: 200,
+                maxTimeout: 1000,
+                factor: 1.1,
+            },
+        });
+        // Write current PID to mutex file for diagnostics/HUD
+        try {
+            fs.writeFileSync(MUTEX_FILE, 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}`);
+    }
+    // Mark this process as the current holder so nested calls skip the queue.
+    _heldDepth = 1;
+    _heldFileRelease = fileRelease;
+    _heldSlotResolve = resolveSlot;
+    // Return a release function that releases both the file lock and the in-process slot
+    return async () => {
+        _heldDepth--;
+        if (_heldDepth > 0)
+            return; // nested regions still active
+        _heldDepth = 0;
+        const rel = _heldFileRelease;
+        const slotResolve = _heldSlotResolve;
+        _heldFileRelease = null;
+        _heldSlotResolve = null;
+        try {
+            if (rel)
+                await rel();
+        }
+        catch { /* already released — safe to ignore */ }
+        if (slotResolve)
+            slotResolve(); // Let the next queued caller proceed
+    };
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+export async function writeLockSafe(data) {
+    const release = await acquireMutex();
+    try {
+        fs.mkdirSync(LOCK_DIR, { recursive: true });
+        fs.writeFileSync(LOCK_FILE, JSON.stringify(data, null, 2), "utf-8");
+    }
+    finally {
+        await release();
+    }
+}
+export async function writeLock(data) {
+    await writeLockSafe(data);
+}
+export function readLock() {
+    if (!fs.existsSync(LOCK_FILE))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(LOCK_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearLock() {
+    try {
+        if (fs.existsSync(LOCK_FILE))
+            fs.unlinkSync(LOCK_FILE);
+    }
+    catch (e) {
+        logDebug(`[Weavetab] [!] Failed to clear lock file: ${e}`);
+    }
+    try {
+        if (fs.existsSync(MUTEX_FILE))
+            fs.unlinkSync(MUTEX_FILE);
+    }
+    catch { /* ignore */ }
+    try {
+        const lockDir = MUTEX_FILE + ".lock";
+        if (fs.existsSync(lockDir))
+            fs.rmSync(lockDir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+/**
+ * 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 function clearLockIfOwned() {
+    try {
+        const lock = readLock();
+        if (!lock || lock.pid !== process.pid) {
+            logDebug(`[Weavetab] clearLockIfOwned: skipping — lock owned by PID ${lock?.pid ?? 'none'}, this PID is ${process.pid}`);
+            return;
+        }
+        clearLock();
+    }
+    catch (e) {
+        logDebug(`[Weavetab] clearLockIfOwned error: ${e}`);
+    }
+}
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Two-factor lock validation: PID alive AND port accepting TCP connections.
+ * Prevents PID-reuse false-positives after a crash.
+ */
+export async function isLockValid(lock) {
+    // Factor 1: PID alive
+    if (lock.pid && !isProcessRunning(lock.pid)) {
+        logDebug(`[Weavetab CDP] Lock invalid: Process ${lock.pid} is not running.`);
+        return false;
+    }
+    // Factor 2: TCP port accepting connections
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        const timeout = setTimeout(() => {
+            logDebug(`[Weavetab CDP] Lock invalid: Timeout connecting to port ${lock.port}.`);
+            socket.destroy();
+            resolve(false);
+        }, 1000); // Reduced timeout to 1s for faster validation
+        socket.connect(lock.port, "127.0.0.1", () => {
+            clearTimeout(timeout);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.on("error", (err) => {
+            logDebug(`[Weavetab CDP] Lock invalid: Error connecting to port ${lock.port} - ${err.message}`);
+            clearTimeout(timeout);
+            resolve(false);
+        });
+    });
+}
+export function isLockPending(lock) {
+    if (!lock.pending)
+        return false;
+    // If it's been pending for more than 15 seconds, consider it stale/failed
+    if (lock.timestamp && Date.now() - lock.timestamp > 15000) {
+        return false;
+    }
+    return true;
+}
+export { acquireMutex };