@jobshimo/browser-link 0.23.7 → 0.23.9

package/dist/extension/background.js

@@ -6,6 +6,7 @@ import { DEFAULT_IDLE_TTL_MINUTES, IDLE_TTL_STORAGE_KEY, IDLE_TTL_UPDATED_AT_STO
 import { DEFAULT_FLOW_RECORDING_ENABLED, FLOW_RECORDING_STORAGE_KEY, FLOW_RECORDING_UPDATED_AT_STORAGE_KEY, normalizeFlowRecordingEnabled, parseIncomingFlowRecordingSettings, } from './flow-recording-policy.js';
 import { buildRecorderJs, buildStopRecorderJs } from './inpage/recorder.js';
 import { DISCARDED_WHILE_SAVING_MESSAGE, appendRecordingStep, buildAmbiguousNote, buildNavigationWaitForStep, generateRecordingSession, isNavigationForRecording, isSameRecordingSession, parseRecordedPayload, toFlowStep, } from './recording.js';
+import { CONNECT_IN_PROGRESS_ERROR, createReconnectScheduler, isInvoluntaryClose, isReconnectStateFresh, parseStoredReconnectState, reconnectStorageKey, tabIdFromReconnectKey, } from './reconnect-policy.js';
 const WS_URL = 'ws://127.0.0.1:17529';
 const CDP_VERSION = '1.3';
 const CONSOLE_BUFFER_MAX = 200;
@@ -631,8 +632,9 @@ async function waitForLoad(tabId, timeoutMs = 20_000) {
 }
 /**
  * `performFind` / `performClick` / `performType` / `performPress` /
- * `performWaitFor` — the extracted bodies of the standalone `find` /
- * `click` / `type` / `press` / `wait_for` cases in `handleTool` below.
+ * `performWaitFor` / `performDrag` — the extracted bodies of the
+ * standalone `find` / `click` / `type` / `press` / `wait_for` / `drag`
+ * cases in `handleTool` below.
  *
  * Both the standalone `case` handlers AND `browser.flow`'s step executor
  * (`runFlow` in `./flow.js`) call these exact functions — there is one
@@ -864,6 +866,279 @@ async function performWaitFor(tabId, state, params) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
+async function performDrag(tabId, params) {
+    try {
+        // Same numeric guard the wire boundary used before this body was
+        // extracted out of `handleDrag`: anything non-finite or negative is
+        // treated as absent, so flow drag steps get identical protection.
+        const num = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+        const clamp = (v, max) => Math.min(v, max);
+        const fromSelector = params.from_selector;
+        const toSelector = params.to_selector;
+        const fromXRaw = num(params.from_x);
+        const fromYRaw = num(params.from_y);
+        const toXRaw = num(params.to_x);
+        const toYRaw = num(params.to_y);
+        // Cap every duration that ends up in a setTimeout to keep CodeQL's
+        // "user-controlled timer duration" check happy and to prevent a
+        // misbehaving agent from parking the bridge for hours on a typo.
+        const durationMs = clamp(num(params.duration_ms) ?? 1500, MAX_DRAG_DURATION_MS);
+        const holdBeforeMoveMs = clamp(num(params.hold_before_move_ms) ?? 0, MAX_DRAG_HOLD_MS);
+        const holdBeforeReleaseMs = clamp(num(params.hold_before_release_ms) ?? 0, MAX_DRAG_HOLD_MS);
+        const hasFromCoords = fromXRaw !== undefined && fromYRaw !== undefined;
+        const hasToCoords = toXRaw !== undefined && toYRaw !== undefined;
+        if (!fromSelector && !hasFromCoords) {
+            return { ok: false, error: 'drag: provide from_selector or both from_x and from_y' };
+        }
+        if (!toSelector && !hasToCoords) {
+            return { ok: false, error: 'drag: provide to_selector or both to_x and to_y' };
+        }
+        const probeExpr = buildDragProbeJs({
+            from_selector: fromSelector,
+            to_selector: toSelector,
+            from_x: fromXRaw,
+            from_y: fromYRaw,
+            to_x: toXRaw,
+            to_y: toYRaw,
+        });
+        const probe = await evaluateInTab(tabId, probeExpr);
+        if (probe.err) {
+            return { ok: false, error: `drag: ${probe.err}` };
+        }
+        if (!probe.from || !probe.to) {
+            return { ok: false, error: 'drag: could not resolve coordinates' };
+        }
+        if (!probe.from.in_viewport) {
+            return {
+                ok: false,
+                error: 'drag: source point is offscreen — scroll first or pass viewport coords',
+            };
+        }
+        if (!probe.to.in_viewport) {
+            return {
+                ok: false,
+                error: 'drag: destination point is offscreen — scroll first or pass viewport coords',
+            };
+        }
+        const fromX = probe.from.x;
+        const fromY = probe.from.y;
+        const toX = probe.to.x;
+        const toY = probe.to.y;
+        const isDraggable = !!probe.draggable;
+        // ~30fps interpolation; minimum 2 steps so the path actually has a midpoint.
+        const steps = durationMs > 0 ? Math.max(2, Math.round(durationMs / 33)) : 1;
+        const stepDelayMs = steps > 0 ? durationMs / steps : 0;
+        const eventsFired = [];
+        // Every branch below reassigns `dragMode` before the final `return`
+        // reads it. (The old `case`-block extraction needed a
+        // no-useless-assignment disable here; inside this try/catch scope the
+        // linter no longer flags the initializer, so the directive is gone.)
+        let dragMode = 'pointer';
+        let interceptReceived = false;
+        const dragStart = Date.now();
+        let interceptionEnabled = false;
+        const interpolate = (t) => ({
+            x: fromX + (toX - fromX) * t,
+            y: fromY + (toY - fromY) * t,
+        });
+        // Mouse move WITH the left button held down. Chrome's HTML5 drag
+        // system only treats movement as a drag when the button state is
+        // signalled on every move after mousePressed; omitting it makes
+        // Blink ignore the move for drag-detection purposes.
+        const moveHeld = (x, y) => cdp(tabId, 'Input.dispatchMouseEvent', {
+            type: 'mouseMoved',
+            x,
+            y,
+            button: 'left',
+            buttons: 1,
+        });
+        // Wiggle distance has to comfortably clear `kDragThreshold` (~5px on
+        // Mac, 4px on Linux/Windows). 5px landed *right* at the boundary and
+        // Chrome did not start the drag — 20px crosses it on every platform.
+        const WIGGLE_PX = 20;
+        // Time to wait for Input.dragIntercepted after the wiggle. 120ms was
+        // enough on local-only synthetic tests but flaky in real Chrome —
+        // 250ms is comfortable without dragging out the overall latency.
+        const INTERCEPT_TIMEOUT_MS = 250;
+        try {
+            if (isDraggable) {
+                try {
+                    await cdp(tabId, 'Input.setInterceptDrags', { enabled: true });
+                    interceptionEnabled = true;
+                }
+                catch {
+                    // setInterceptDrags is experimental — fall back to pointer mode silently.
+                }
+            }
+            if (interceptionEnabled) {
+                // Arm the listener BEFORE the press+wiggle that may trigger it.
+                const interceptPromise = waitForCdpEvent(tabId, 'Input.dragIntercepted', INTERCEPT_TIMEOUT_MS);
+                await cdp(tabId, 'Input.dispatchMouseEvent', {
+                    type: 'mouseMoved',
+                    x: fromX,
+                    y: fromY,
+                });
+                await cdp(tabId, 'Input.dispatchMouseEvent', {
+                    type: 'mousePressed',
+                    x: fromX,
+                    y: fromY,
+                    button: 'left',
+                    clickCount: 1,
+                });
+                if (holdBeforeMoveMs > 0)
+                    await sleep(holdBeforeMoveMs);
+                // Wiggle toward the destination so Chrome's native drag system
+                // crosses its activation threshold. Direction matters for libs
+                // that have direction-sensitive activation constraints.
+                const dx = toX - fromX;
+                const dy = toY - fromY;
+                const len = Math.hypot(dx, dy) || 1;
+                const wx = fromX + (dx / len) * WIGGLE_PX;
+                const wy = fromY + (dy / len) * WIGGLE_PX;
+                await moveHeld(wx, wy);
+                const intercepted = await interceptPromise;
+                if (intercepted) {
+                    dragMode = 'html5';
+                    interceptReceived = true;
+                    eventsFired.push('Input.dragIntercepted');
+                    const dragData = intercepted.data;
+                    for (let i = 1; i <= steps; i++) {
+                        const t = i / steps;
+                        const { x, y } = interpolate(t);
+                        await moveHeld(x, y);
+                        await cdp(tabId, 'Input.dispatchDragEvent', {
+                            type: 'dragOver',
+                            x,
+                            y,
+                            data: dragData,
+                        });
+                        if (i === 1)
+                            eventsFired.push('dragOver');
+                        if (stepDelayMs > 0)
+                            await sleep(stepDelayMs);
+                    }
+                    await cdp(tabId, 'Input.dispatchDragEvent', {
+                        type: 'dragEnter',
+                        x: toX,
+                        y: toY,
+                        data: dragData,
+                    });
+                    eventsFired.push('dragEnter');
+                    await cdp(tabId, 'Input.dispatchDragEvent', {
+                        type: 'dragOver',
+                        x: toX,
+                        y: toY,
+                        data: dragData,
+                    });
+                    if (holdBeforeReleaseMs > 0)
+                        await sleep(holdBeforeReleaseMs);
+                    await cdp(tabId, 'Input.dispatchDragEvent', {
+                        type: 'drop',
+                        x: toX,
+                        y: toY,
+                        data: dragData,
+                    });
+                    eventsFired.push('drop');
+                    await cdp(tabId, 'Input.dispatchMouseEvent', {
+                        type: 'mouseReleased',
+                        x: toX,
+                        y: toY,
+                        button: 'left',
+                        clickCount: 1,
+                    });
+                }
+                else {
+                    // Element was tagged draggable but no native drag fired — the page
+                    // either preventDefault'd dragstart or wires its own pointer logic.
+                    // Continue with pointer-only events from where we already pressed.
+                    dragMode = 'pointer';
+                    for (let i = 1; i <= steps; i++) {
+                        const t = i / steps;
+                        const { x, y } = interpolate(t);
+                        await moveHeld(x, y);
+                        if (stepDelayMs > 0)
+                            await sleep(stepDelayMs);
+                    }
+                    if (holdBeforeReleaseMs > 0)
+                        await sleep(holdBeforeReleaseMs);
+                    await cdp(tabId, 'Input.dispatchMouseEvent', {
+                        type: 'mouseReleased',
+                        x: toX,
+                        y: toY,
+                        button: 'left',
+                        clickCount: 1,
+                    });
+                }
+            }
+            else {
+                // Pointer-only branch: no native drag involvement at all.
+                dragMode = 'pointer';
+                await cdp(tabId, 'Input.dispatchMouseEvent', {
+                    type: 'mouseMoved',
+                    x: fromX,
+                    y: fromY,
+                });
+                await cdp(tabId, 'Input.dispatchMouseEvent', {
+                    type: 'mousePressed',
+                    x: fromX,
+                    y: fromY,
+                    button: 'left',
+                    clickCount: 1,
+                });
+                if (holdBeforeMoveMs > 0)
+                    await sleep(holdBeforeMoveMs);
+                for (let i = 1; i <= steps; i++) {
+                    const t = i / steps;
+                    const { x, y } = interpolate(t);
+                    await moveHeld(x, y);
+                    if (stepDelayMs > 0)
+                        await sleep(stepDelayMs);
+                }
+                if (holdBeforeReleaseMs > 0)
+                    await sleep(holdBeforeReleaseMs);
+                await cdp(tabId, 'Input.dispatchMouseEvent', {
+                    type: 'mouseReleased',
+                    x: toX,
+                    y: toY,
+                    button: 'left',
+                    clickCount: 1,
+                });
+            }
+        }
+        finally {
+            // Critical: leaving interception on would block the human user from
+            // dragging anything in this tab. Best-effort cleanup, swallow errors.
+            if (interceptionEnabled) {
+                try {
+                    await cdp(tabId, 'Input.setInterceptDrags', { enabled: false });
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        return {
+            ok: true,
+            result: {
+                from: { x: fromX, y: fromY, selector: fromSelector ?? null },
+                to: { x: toX, y: toY, selector: toSelector ?? null },
+                duration_ms_actual: Date.now() - dragStart,
+                drag_mode: dragMode,
+                interception_attempted: interceptionEnabled,
+                intercept_received: interceptReceived,
+                events_fired: eventsFired,
+            },
+        };
+    }
+    catch (err) {
+        // The pre-extraction `case 'drag'` let thrown errors bubble to
+        // `handleTool`'s outer catch, which produced this exact same
+        // `err.message` string — converting here instead keeps the standalone
+        // wire behavior identical while giving `runFlow` the `ActionOutcome`
+        // shape it expects from every other perform* function.
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
 /**
  * `handlePing` through `handleSetPermission` — the extracted bodies of the
  * remaining standalone tool cases in `handleTool` below that never got the
@@ -960,6 +1235,7 @@ async function handleFlow(tabId, state, msg, p) {
         performType: (params) => performType(tabId, params),
         performPress: (params) => performPress(tabId, params),
         performWaitFor: (params) => performWaitFor(tabId, state, params),
+        performDrag: (params) => performDrag(tabId, params),
         buildRecoverySnapshot: () => evaluateInTab(tabId, buildSnapshotJs({ only_interactive: true, max_interactive: 40 })),
     });
     // The wire-level response is ok:true whenever the flow RAN (even a
@@ -969,285 +1245,29 @@ async function handleFlow(tabId, state, msg, p) {
     return { kind: 'tool.response', id: msg.id, ok: true, result: flowResult };
 }
 async function handleDrag(tabId, msg, p, optStr) {
+    // Thin wire wrapper over performDrag — the same pattern the standalone
+    // click/type/press/wait_for cases use over their perform* functions.
+    // Numbers pass through with a plain typeof check; performDrag applies
+    // the full finite/non-negative guard and the duration/hold clamps.
     const optNum = (key) => {
         const v = p[key];
-        return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+        return typeof v === 'number' ? v : undefined;
     };
-    const clamp = (v, max) => Math.min(v, max);
-    const fromSelector = optStr('from_selector');
-    const toSelector = optStr('to_selector');
-    const fromXRaw = optNum('from_x');
-    const fromYRaw = optNum('from_y');
-    const toXRaw = optNum('to_x');
-    const toYRaw = optNum('to_y');
-    // Cap every duration that ends up in a setTimeout to keep CodeQL's
-    // "user-controlled timer duration" check happy and to prevent a
-    // misbehaving agent from parking the bridge for hours on a typo.
-    const durationMs = clamp(optNum('duration_ms') ?? 1500, MAX_DRAG_DURATION_MS);
-    const holdBeforeMoveMs = clamp(optNum('hold_before_move_ms') ?? 0, MAX_DRAG_HOLD_MS);
-    const holdBeforeReleaseMs = clamp(optNum('hold_before_release_ms') ?? 0, MAX_DRAG_HOLD_MS);
-    const hasFromCoords = fromXRaw !== undefined && fromYRaw !== undefined;
-    const hasToCoords = toXRaw !== undefined && toYRaw !== undefined;
-    if (!fromSelector && !hasFromCoords) {
-        return {
-            kind: 'tool.response',
-            id: msg.id,
-            ok: false,
-            error: 'drag: provide from_selector or both from_x and from_y',
-        };
-    }
-    if (!toSelector && !hasToCoords) {
-        return {
-            kind: 'tool.response',
-            id: msg.id,
-            ok: false,
-            error: 'drag: provide to_selector or both to_x and to_y',
-        };
-    }
-    const probeExpr = buildDragProbeJs({
-        from_selector: fromSelector,
-        to_selector: toSelector,
-        from_x: fromXRaw,
-        from_y: fromYRaw,
-        to_x: toXRaw,
-        to_y: toYRaw,
-    });
-    const probe = await evaluateInTab(tabId, probeExpr);
-    if (probe.err) {
-        return { kind: 'tool.response', id: msg.id, ok: false, error: `drag: ${probe.err}` };
-    }
-    if (!probe.from || !probe.to) {
-        return {
-            kind: 'tool.response',
-            id: msg.id,
-            ok: false,
-            error: 'drag: could not resolve coordinates',
-        };
-    }
-    if (!probe.from.in_viewport) {
-        return {
-            kind: 'tool.response',
-            id: msg.id,
-            ok: false,
-            error: 'drag: source point is offscreen — scroll first or pass viewport coords',
-        };
-    }
-    if (!probe.to.in_viewport) {
-        return {
-            kind: 'tool.response',
-            id: msg.id,
-            ok: false,
-            error: 'drag: destination point is offscreen — scroll first or pass viewport coords',
-        };
-    }
-    const fromX = probe.from.x;
-    const fromY = probe.from.y;
-    const toX = probe.to.x;
-    const toY = probe.to.y;
-    const isDraggable = !!probe.draggable;
-    // ~30fps interpolation; minimum 2 steps so the path actually has a midpoint.
-    const steps = durationMs > 0 ? Math.max(2, Math.round(durationMs / 33)) : 1;
-    const stepDelayMs = steps > 0 ? durationMs / steps : 0;
-    const eventsFired = [];
-    // Every branch below reassigns `dragMode` before the final `return` reads it.
-    let dragMode = 'pointer'; // eslint-disable-line no-useless-assignment -- see comment above
-    let interceptReceived = false;
-    const dragStart = Date.now();
-    let interceptionEnabled = false;
-    const interpolate = (t) => ({
-        x: fromX + (toX - fromX) * t,
-        y: fromY + (toY - fromY) * t,
+    const outcome = await performDrag(tabId, {
+        from_selector: optStr('from_selector'),
+        from_x: optNum('from_x'),
+        from_y: optNum('from_y'),
+        to_selector: optStr('to_selector'),
+        to_x: optNum('to_x'),
+        to_y: optNum('to_y'),
+        duration_ms: optNum('duration_ms'),
+        hold_before_move_ms: optNum('hold_before_move_ms'),
+        hold_before_release_ms: optNum('hold_before_release_ms'),
     });
-    // Mouse move WITH the left button held down. Chrome's HTML5 drag
-    // system only treats movement as a drag when the button state is
-    // signalled on every move after mousePressed; omitting it makes
-    // Blink ignore the move for drag-detection purposes.
-    const moveHeld = (x, y) => cdp(tabId, 'Input.dispatchMouseEvent', {
-        type: 'mouseMoved',
-        x,
-        y,
-        button: 'left',
-        buttons: 1,
-    });
-    // Wiggle distance has to comfortably clear `kDragThreshold` (~5px on
-    // Mac, 4px on Linux/Windows). 5px landed *right* at the boundary and
-    // Chrome did not start the drag — 20px crosses it on every platform.
-    const WIGGLE_PX = 20;
-    // Time to wait for Input.dragIntercepted after the wiggle. 120ms was
-    // enough on local-only synthetic tests but flaky in real Chrome —
-    // 250ms is comfortable without dragging out the overall latency.
-    const INTERCEPT_TIMEOUT_MS = 250;
-    try {
-        if (isDraggable) {
-            try {
-                await cdp(tabId, 'Input.setInterceptDrags', { enabled: true });
-                interceptionEnabled = true;
-            }
-            catch {
-                // setInterceptDrags is experimental — fall back to pointer mode silently.
-            }
-        }
-        if (interceptionEnabled) {
-            // Arm the listener BEFORE the press+wiggle that may trigger it.
-            const interceptPromise = waitForCdpEvent(tabId, 'Input.dragIntercepted', INTERCEPT_TIMEOUT_MS);
-            await cdp(tabId, 'Input.dispatchMouseEvent', {
-                type: 'mouseMoved',
-                x: fromX,
-                y: fromY,
-            });
-            await cdp(tabId, 'Input.dispatchMouseEvent', {
-                type: 'mousePressed',
-                x: fromX,
-                y: fromY,
-                button: 'left',
-                clickCount: 1,
-            });
-            if (holdBeforeMoveMs > 0)
-                await sleep(holdBeforeMoveMs);
-            // Wiggle toward the destination so Chrome's native drag system
-            // crosses its activation threshold. Direction matters for libs
-            // that have direction-sensitive activation constraints.
-            const dx = toX - fromX;
-            const dy = toY - fromY;
-            const len = Math.hypot(dx, dy) || 1;
-            const wx = fromX + (dx / len) * WIGGLE_PX;
-            const wy = fromY + (dy / len) * WIGGLE_PX;
-            await moveHeld(wx, wy);
-            const intercepted = await interceptPromise;
-            if (intercepted) {
-                dragMode = 'html5';
-                interceptReceived = true;
-                eventsFired.push('Input.dragIntercepted');
-                const dragData = intercepted.data;
-                for (let i = 1; i <= steps; i++) {
-                    const t = i / steps;
-                    const { x, y } = interpolate(t);
-                    await moveHeld(x, y);
-                    await cdp(tabId, 'Input.dispatchDragEvent', {
-                        type: 'dragOver',
-                        x,
-                        y,
-                        data: dragData,
-                    });
-                    if (i === 1)
-                        eventsFired.push('dragOver');
-                    if (stepDelayMs > 0)
-                        await sleep(stepDelayMs);
-                }
-                await cdp(tabId, 'Input.dispatchDragEvent', {
-                    type: 'dragEnter',
-                    x: toX,
-                    y: toY,
-                    data: dragData,
-                });
-                eventsFired.push('dragEnter');
-                await cdp(tabId, 'Input.dispatchDragEvent', {
-                    type: 'dragOver',
-                    x: toX,
-                    y: toY,
-                    data: dragData,
-                });
-                if (holdBeforeReleaseMs > 0)
-                    await sleep(holdBeforeReleaseMs);
-                await cdp(tabId, 'Input.dispatchDragEvent', {
-                    type: 'drop',
-                    x: toX,
-                    y: toY,
-                    data: dragData,
-                });
-                eventsFired.push('drop');
-                await cdp(tabId, 'Input.dispatchMouseEvent', {
-                    type: 'mouseReleased',
-                    x: toX,
-                    y: toY,
-                    button: 'left',
-                    clickCount: 1,
-                });
-            }
-            else {
-                // Element was tagged draggable but no native drag fired — the page
-                // either preventDefault'd dragstart or wires its own pointer logic.
-                // Continue with pointer-only events from where we already pressed.
-                dragMode = 'pointer';
-                for (let i = 1; i <= steps; i++) {
-                    const t = i / steps;
-                    const { x, y } = interpolate(t);
-                    await moveHeld(x, y);
-                    if (stepDelayMs > 0)
-                        await sleep(stepDelayMs);
-                }
-                if (holdBeforeReleaseMs > 0)
-                    await sleep(holdBeforeReleaseMs);
-                await cdp(tabId, 'Input.dispatchMouseEvent', {
-                    type: 'mouseReleased',
-                    x: toX,
-                    y: toY,
-                    button: 'left',
-                    clickCount: 1,
-                });
-            }
-        }
-        else {
-            // Pointer-only branch: no native drag involvement at all.
-            dragMode = 'pointer';
-            await cdp(tabId, 'Input.dispatchMouseEvent', {
-                type: 'mouseMoved',
-                x: fromX,
-                y: fromY,
-            });
-            await cdp(tabId, 'Input.dispatchMouseEvent', {
-                type: 'mousePressed',
-                x: fromX,
-                y: fromY,
-                button: 'left',
-                clickCount: 1,
-            });
-            if (holdBeforeMoveMs > 0)
-                await sleep(holdBeforeMoveMs);
-            for (let i = 1; i <= steps; i++) {
-                const t = i / steps;
-                const { x, y } = interpolate(t);
-                await moveHeld(x, y);
-                if (stepDelayMs > 0)
-                    await sleep(stepDelayMs);
-            }
-            if (holdBeforeReleaseMs > 0)
-                await sleep(holdBeforeReleaseMs);
-            await cdp(tabId, 'Input.dispatchMouseEvent', {
-                type: 'mouseReleased',
-                x: toX,
-                y: toY,
-                button: 'left',
-                clickCount: 1,
-            });
-        }
-    }
-    finally {
-        // Critical: leaving interception on would block the human user from
-        // dragging anything in this tab. Best-effort cleanup, swallow errors.
-        if (interceptionEnabled) {
-            try {
-                await cdp(tabId, 'Input.setInterceptDrags', { enabled: false });
-            }
-            catch {
-                // ignore
-            }
-        }
+    if (!outcome.ok) {
+        return { kind: 'tool.response', id: msg.id, ok: false, error: outcome.error };
     }
-    return {
-        kind: 'tool.response',
-        id: msg.id,
-        ok: true,
-        result: {
-            from: { x: fromX, y: fromY, selector: fromSelector ?? null },
-            to: { x: toX, y: toY, selector: toSelector ?? null },
-            duration_ms_actual: Date.now() - dragStart,
-            drag_mode: dragMode,
-            interception_attempted: interceptionEnabled,
-            intercept_received: interceptReceived,
-            events_fired: eventsFired,
-        },
-    };
+    return { kind: 'tool.response', id: msg.id, ok: true, result: outcome.result };
 }
 async function handleDialogRespond(tabId, msg, p, optStr) {
     const accept = p.accept === true;
@@ -1440,6 +1460,16 @@ async function cleanup(tabId) {
     const state = tabStates.get(tabId);
     if (!state)
         return;
+    // Delete the tracking entry SYNCHRONOUSLY, before any await below: the
+    // reconnect policy's CloseContext.tracked contract promises that every
+    // extension-initiated teardown deletes state BEFORE the WS close event
+    // dispatches. ws.close() further down fires that event on a later turn,
+    // so deleting here keeps the promise — the close handler then sees an
+    // untracked socket and never auto-reconnects a teardown the extension
+    // itself initiated. The awaited steps below only need the captured
+    // `state` and raw CDP calls, never the map entry — and deleting first
+    // also makes a re-entrant cleanup a no-op instead of a double detach.
+    tabStates.delete(tabId);
     // Recording never survives a disconnect — there is no server connection
     // left to save to, and leaving captured-but-unsaved steps around after
     // the tab drops its bridge would be a surprising place for them to
@@ -1471,7 +1501,6 @@ async function cleanup(tabId) {
             // Best effort — the resource may already be detached/closed.
         }
     }
-    tabStates.delete(tabId);
 }
 chrome.debugger.onEvent.addListener((source, method, params) => {
     if (source.tabId === undefined)
@@ -1517,7 +1546,131 @@ async function forgetTabId(chromeTabId) {
         /* ignore */
     }
 }
+/* Auto-reconnect after an involuntary WS close.
+ *
+ * When a REGISTERED tab's WebSocket dies under us (unclean close — the
+ * primary MCP server crashed or restarted), the scheduler below retries
+ * `connectTab` with per-tab backoff (see RECONNECT_DELAYS_MS in
+ * reconnect-policy.ts), reusing the preserved `prevTabId:*` id so the new
+ * primary can keep the same tab_id (or emit `tab-renamed` if it can't —
+ * existing contract, nothing new on the wire). Every EXTENSION-initiated
+ * teardown (explicit disconnect, tab removal, idle park, debugger detach)
+ * runs `cleanup` BEFORE the close event dispatches, so the close handler
+ * sees an untracked socket and never schedules; a CLEAN close from the
+ * server (browser.reset) is a deliberate goodbye and never schedules
+ * either — the popup Connect button stays the fallback for both, as today.
+ *
+ * MV3 durability: each scheduled attempt is mirrored into
+ * `chrome.storage.session` (`pendingReconnect:*`, right next to the
+ * `prevTabId:*` keys). Plain timers cover the common case — the backoff
+ * span sits inside the service worker's idle grace, and every attempt
+ * touches chrome.* APIs which resets the idle clock — but if the worker is
+ * killed anyway, `resumePendingReconnects` below picks the budget back up
+ * on the next wake, and entries older than RECONNECT_STATE_TTL_MS are
+ * discarded rather than surprising the user minutes later. */
+async function storeReconnectState(tabId, attempt) {
+    try {
+        await chrome.storage.session.set({
+            [reconnectStorageKey(tabId)]: { attempt, updatedAt: Date.now() },
+        });
+    }
+    catch {
+        /* non-fatal — worst case a killed service worker cannot resume this retry */
+    }
+}
+async function clearReconnectState(tabId) {
+    try {
+        await chrome.storage.session.remove(reconnectStorageKey(tabId));
+    }
+    catch {
+        /* ignore */
+    }
+}
+const reconnectScheduler = createReconnectScheduler({
+    attempt: async (tabId) => {
+        try {
+            await chrome.tabs.get(tabId);
+        }
+        catch {
+            // The Chrome tab itself is gone — nothing left to reconnect.
+            return 'stop';
+        }
+        const existing = tabStates.get(tabId);
+        if (existing) {
+            // A live bridge already exists (e.g. the user pressed Connect while
+            // a retry was pending) — done. A state whose socket is not OPEN yet
+            // belongs to a connect attempt still mid-flight (cleanup deletes
+            // state synchronously, so it never lingers here); keep the backoff
+            // going instead of declaring victory early.
+            return existing.ws?.readyState === WebSocket.OPEN ? 'connected' : 'retry';
+        }
+        try {
+            const result = await connectTab(tabId);
+            return result.ok ? 'connected' : 'retry';
+        }
+        catch {
+            return 'retry';
+        }
+    },
+    onStateChange: (tabId, state) => {
+        if (state)
+            void storeReconnectState(tabId, state.attempt);
+        else
+            void clearReconnectState(tabId);
+    },
+});
+/** Resume reconnect cycles a killed service worker left behind. Runs once
+ * per worker start (top-level call below) — `chrome.storage.session`
+ * survives worker restarts but not browser restarts, which is exactly the
+ * lifetime the retry budget should have. */
+async function resumePendingReconnects() {
+    let stored;
+    try {
+        stored = await chrome.storage.session.get(null);
+    }
+    catch {
+        return;
+    }
+    const now = Date.now();
+    for (const [key, value] of Object.entries(stored)) {
+        const tabId = tabIdFromReconnectKey(key);
+        if (tabId === null)
+            continue;
+        const state = parseStoredReconnectState(value);
+        if (state && isReconnectStateFresh(state.updatedAt, now) && !tabStates.has(tabId)) {
+            reconnectScheduler.schedule(tabId, state.attempt);
+        }
+        else {
+            void clearReconnectState(tabId);
+        }
+    }
+}
+void resumePendingReconnects();
+/** Tabs with a `connectTab` currently in flight. The `tabStates.has` check
+ * inside `doConnectTab` alone cannot prevent two concurrent connects — the
+ * state lands only after three awaited chrome.* calls — so this SYNCHRONOUS
+ * check-and-set is the real per-tab reentrancy guard. */
+const connectsInFlight = new Set();
 async function connectTab(tabId) {
+    if (connectsInFlight.has(tabId)) {
+        // A concurrent connect (popup Connect racing a scheduled reconnect
+        // attempt, or vice versa) — the in-flight attempt owns the tab.
+        // Answer benignly instead of letting a second attempt fail its
+        // debugger attach with a confusing error; the popup renders this
+        // exact message as the "Reconnecting" card, not an error.
+        return { ok: false, error: CONNECT_IN_PROGRESS_ERROR };
+    }
+    connectsInFlight.add(tabId);
+    try {
+        return await doConnectTab(tabId);
+    }
+    finally {
+        connectsInFlight.delete(tabId);
+    }
+}
+/** Body of `connectTab` — call only through the wrapper above, which holds
+ * the per-tab in-flight lock for the full duration of the attempt. */
+async function doConnectTab(tabId) {
     if (tabStates.has(tabId)) {
         return { ok: false, error: 'This tab is already connected' };
     }
@@ -1591,6 +1744,13 @@ async function connectTab(tabId) {
                 // new kind into the tool.request handler.
                 switch (msg.kind) {
                     case 'tab.registered': {
+                        // A successful registration ends any reconnect cycle for this
+                        // tab. Covers the resume path re-arming a tab the user just
+                        // connected manually (resumePendingReconnects's tabStates
+                        // check races connectTab); when the SCHEDULER drove this very
+                        // connect, its in-flight guard makes this cancel a clean,
+                        // notify-once end of the cycle.
+                        reconnectScheduler.cancel(tabId);
                         state.serverTabId = msg.payload.tabId;
                         // serverVersion is optional on the wire so older servers that
                         // predate the field still parse — narrow on `typeof string`.
@@ -1652,21 +1812,47 @@ async function connectTab(tabId) {
                 }
             })();
         });
+        // A WebSocket 'error' is always followed by a 'close', so teardown
+        // lives in the close handler alone — this one only settles a
+        // pre-registration connect failure with the friendlier diagnosis (for
+        // a post-registration drop `settle` is already spent and this no-ops).
         ws.addEventListener('error', () => {
-            void cleanup(tabId).catch(() => {
-                // Best effort — already-detached state is fine.
-            });
             settle({ ok: false, error: 'WebSocket connection failed. Is the MCP server running?' });
         });
-        ws.addEventListener('close', () => {
+        ws.addEventListener('close', (ev) => {
+            const current = tabStates.get(tabId);
+            if (current !== undefined && current.ws !== ws) {
+                // A newer connection already owns this tab — this close belongs to
+                // a superseded socket, and tearing state down here would kill the
+                // NEW bridge rather than the one that just died.
+                settle({ ok: false, error: 'WebSocket closed before registration' });
+                return;
+            }
+            // Decide BEFORE cleanup wipes the evidence: an unclean close of a
+            // still-tracked, registered connection means the server died under
+            // us — the one case the auto-reconnect scheduler exists for. See
+            // the reconnect section doc above storeReconnectState for why every
+            // other close (explicit disconnect, tab removal, idle park,
+            // browser.reset's clean goodbye) falls out of this predicate.
+            const involuntary = isInvoluntaryClose({
+                tracked: current?.ws === ws,
+                registered: current?.serverTabId !== undefined,
+                wasClean: ev.wasClean,
+            });
             void cleanup(tabId).catch(() => {
                 // Best effort — already-detached state is fine.
             });
             settle({ ok: false, error: 'WebSocket closed before registration' });
+            if (involuntary)
+                reconnectScheduler.schedule(tabId);
         });
     });
 }
 async function disconnectTab(tabId) {
+    // Explicit user intent beats any pending auto-reconnect — cancel it
+    // first so a scheduled retry cannot resurrect the bridge right after
+    // the user asked for it to go away.
+    reconnectScheduler.cancel(tabId);
     await cleanup(tabId);
     // Explicit user-driven disconnect → forget the previous tab id so the
     // next "Connect" starts from a clean slate (vs. an involuntary
@@ -1676,8 +1862,17 @@ async function disconnectTab(tabId) {
 }
 function getTabStatus(tabId) {
     const state = tabStates.get(tabId);
-    if (!state)
+    if (!state) {
+        // Keep the popup truthful while auto-reconnect is working: "not
+        // connected, but actively retrying" rather than a flat idle state.
+        // `connectsInFlight` covers the short gap inside a live attempt
+        // before its TabState lands — without it the popup's poll could
+        // misread that gap as idle and freeze the card there.
+        if (reconnectScheduler.isPending(tabId) || connectsInFlight.has(tabId)) {
+            return { connected: false, reconnecting: true };
+        }
         return { connected: false };
+    }
     return { connected: true, serverTabId: state.serverTabId };
 }
 /**
@@ -2041,6 +2236,12 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
     if (!isRuntimeMessage(msg))
         return false;
     if (msg.action === 'connect') {
+        // An explicit Connect cancels any FUTURE auto-reconnect retries for
+        // this tab. If a scheduled attempt is already mid-flight (cancel
+        // cannot abort it), connectTab's per-tab in-flight lock turns this
+        // call into a benign "already in progress" result instead of a
+        // second concurrent connect.
+        reconnectScheduler.cancel(msg.tabId);
         void connectTab(msg.tabId).then(sendResponse);
         return true;
     }
@@ -2086,6 +2287,8 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
     return false;
 });
 chrome.tabs.onRemoved.addListener((tabId) => {
+    // No tab, no reconnect — abort any pending retry cycle for it.
+    reconnectScheduler.cancel(tabId);
     void cleanup(tabId).catch(() => {
         // Best effort.
     });