@jobshimo/browser-link 0.40.0 → 0.42.0

package/dist/extension/background.js

@@ -13,6 +13,8 @@ import { DEFAULT_FLOW_RECORDING_ENABLED, FLOW_RECORDING_STORAGE_KEY, FLOW_RECORD
 import { buildRecorderJs, buildStopRecorderJs } from './inpage/recorder.js';
 import { DISCARDED_WHILE_SAVING_MESSAGE, appendRecordingStep, buildAmbiguousNote, buildNavigationWaitForStep, generateRecordingSession, isNavigationForRecording, isSameRecordingSession, parseRecordedPayload, toFlowStep, } from './recording.js';
 import { ALARM_MIN_DELAY_MS, CONNECT_IN_PROGRESS_ERROR, createReconnectScheduler, isInvoluntaryClose, planResume, reconnectStorageKey, tabIdFromReconnectKey, } from './reconnect-policy.js';
+import { REPAIR_TIMEOUT_MS, describeReconnectResults, describeRepairReply, planRepair, prevTabIdKey, rememberedTabIds, } from './repair-policy.js';
+import { computeVersionCheck } from './version-status.js';
 const WS_URL = 'ws://127.0.0.1:17529';
 const CDP_VERSION = '1.3';
 const CONSOLE_BUFFER_MAX = 200;
@@ -148,12 +150,21 @@ function isRuntimeMessage(msg) {
     const m = msg;
     if (m.action === 'versionCheck')
         return true;
+    if (m.action === 'repairConnection')
+        return true;
     if (m.action === 'openActivityWindow')
         return true;
     if (m.action === 'activityQuery')
         return true;
     if (m.action === 'activityPurge')
         return true;
+    if (m.action === 'adminDescribe')
+        return true;
+    if (m.action === 'adminAction') {
+        const v = m.value;
+        return (typeof m.id === 'string' &&
+            (v === undefined || typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean'));
+    }
     if (m.action === 'saveRecording') {
         return typeof m.tabId === 'number' && typeof m.name === 'string';
     }
@@ -250,6 +261,61 @@ function purgeActivity(input) {
     // A dry run only counts — no VACUUM, so it gets the short budget.
     input.dryRun === true ? ACTIVITY_QUERY_TIMEOUT_MS : ACTIVITY_PURGE_TIMEOUT_MS);
 }
+const pendingAdminRequests = new Map();
+/** Settle one admin reply; an unknown or timed-out id is dropped (see
+ * `settleActivityRequest` for why). */
+function settleAdminRequest(requestId, reply) {
+    const pending = pendingAdminRequests.get(requestId);
+    if (typeof pending !== 'function')
+        return;
+    pendingAdminRequests.delete(requestId);
+    pending(reply);
+}
+/** Describing and most actions are local config reads and writes. */
+const ADMIN_TIMEOUT_MS = 5_000;
+/** `doctor` probes ports and processes server-side and is slow by nature. */
+const ADMIN_DOCTOR_TIMEOUT_MS = 20_000;
+/**
+ * One correlated admin round trip over any connected tab's socket — the same
+ * shape as `activityRoundTrip`. `onFailure` builds the reply kind the caller
+ * expects, so `not-connected` and `timeout` reach the popup in the same
+ * envelope a real answer would.
+ */
+async function adminRoundTrip(frame, timeoutMs, onFailure) {
+    const socket = [...tabStates.values()]
+        .map((s) => s.ws)
+        .find((ws) => ws !== undefined && ws.readyState === WebSocket.OPEN);
+    if (!socket)
+        return onFailure('', 'not-connected');
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            pendingAdminRequests.delete(requestId);
+            resolve(onFailure(requestId, 'timeout'));
+        }, timeoutMs);
+        pendingAdminRequests.set(requestId, (reply) => {
+            clearTimeout(timer);
+            resolve(reply);
+        });
+        send(socket, frame(requestId));
+    });
+}
+function adminDescribe() {
+    return adminRoundTrip((request_id) => ({ kind: 'admin.describe', request_id }), ADMIN_TIMEOUT_MS, (request_id, error) => ({ kind: 'admin.state', request_id, ok: false, error }));
+}
+function adminAction(input) {
+    return adminRoundTrip((request_id) => ({
+        kind: 'admin.action',
+        request_id,
+        id: input.id,
+        ...(input.value !== undefined ? { value: input.value } : {}),
+        ...(input.confirm === true ? { confirm: true } : {}),
+    }), input.id === 'doctor' ? ADMIN_DOCTOR_TIMEOUT_MS : ADMIN_TIMEOUT_MS, (request_id, error) => ({
+        kind: 'admin.action.result',
+        request_id,
+        result: { ok: false, error },
+    }));
+}
 /** Chrome window geometry for the Activity panel. Wide enough for the full
  * row — time, agent, tool, target and outcome — without wrapping, which is
  * the entire reason this is not the 320px popup. */
@@ -2486,7 +2552,7 @@ chrome.debugger.onEvent.addListener((source, method, params) => {
  * stale tab_ids after a re-election.
  */
 async function readPreviousTabId(chromeTabId) {
-    const key = `prevTabId:${chromeTabId}`;
+    const key = prevTabIdKey(chromeTabId);
     try {
         const data = await chrome.storage.session.get(key);
         const v = data[key];
@@ -2497,7 +2563,7 @@ async function readPreviousTabId(chromeTabId) {
     }
 }
 async function storeTabId(chromeTabId, serverTabId) {
-    const key = `prevTabId:${chromeTabId}`;
+    const key = prevTabIdKey(chromeTabId);
     try {
         await chrome.storage.session.set({ [key]: serverTabId });
     }
@@ -2506,7 +2572,7 @@ async function storeTabId(chromeTabId, serverTabId) {
     }
 }
 async function forgetTabId(chromeTabId) {
-    const key = `prevTabId:${chromeTabId}`;
+    const key = prevTabIdKey(chromeTabId);
     try {
         await chrome.storage.session.remove(key);
     }
@@ -2770,6 +2836,13 @@ async function doConnectTab(tabId) {
                         if (typeof msg.payload.serverVersion === 'string') {
                             state.serverVersion = msg.payload.serverVersion;
                         }
+                        // Same narrowing for the 0.41.0 fields.
+                        if (typeof msg.payload.installedVersion === 'string') {
+                            state.installedVersion = msg.payload.installedVersion;
+                        }
+                        if (typeof msg.payload.serverPid === 'number') {
+                            state.serverPid = msg.payload.serverPid;
+                        }
                         // Remember this id so the next reconnect (after a primary swap)
                         // asks the new primary to honour it. The primary emits
                         // `tab-renamed` in the bridge event log if it can't.
@@ -2845,6 +2918,17 @@ async function doConnectTab(tabId) {
                         settleActivityRequest(msg.request_id, msg);
                         return;
                     }
+                    // Not tab activity either: only the popup's Admin section waits on it.
+                    case 'admin.state':
+                    case 'admin.action.result': {
+                        settleAdminRequest(msg.request_id, msg);
+                        return;
+                    }
+                    case 'bridge.repair.result': {
+                        // Not tab activity: the popup's Repair button is waiting on it.
+                        settleRepairRequest(msg);
+                        return;
+                    }
                     default: {
                         // Compile-time exhaustiveness check; at runtime an unknown kind
                         // (newer server, older extension) is ignored defensively.
@@ -2927,17 +3011,87 @@ function getTabStatus(tabId) {
 function getVersionCheck() {
     const extension = chrome.runtime.getManifest().version;
     let server = null;
+    let installed = null;
     for (const s of tabStates.values()) {
         if (typeof s.serverVersion === 'string' && s.serverVersion.length > 0) {
             server = s.serverVersion;
+            installed =
+                typeof s.installedVersion === 'string' && s.installedVersion.length > 0
+                    ? s.installedVersion
+                    : null;
             break;
         }
     }
-    return {
-        extension,
-        server,
-        aligned: server === null ? null : server === extension,
-    };
+    return computeVersionCheck({ extension, server, installed });
+}
+/* "Repair connection" (popup button). The decision lives in repair-policy.ts;
+ * this is the thin wiring that gathers its inputs and carries out the step. */
+/** The one in-flight `bridge.repair`, keyed by request id. A late or unknown
+ * reply is dropped, same rule as `settleActivityRequest`. */
+const pendingRepairs = new Map();
+function settleRepairRequest(reply) {
+    const pending = pendingRepairs.get(reply.request_id);
+    if (typeof pending !== 'function')
+        return;
+    pendingRepairs.delete(reply.request_id);
+    pending(reply);
+}
+async function readRememberedTabIds() {
+    try {
+        return rememberedTabIds(await chrome.storage.session.get(null));
+    }
+    catch {
+        return [];
+    }
+}
+/** Send `bridge.repair` on one open socket and wait for the answer. On
+ * success the server drops every socket uncleanly and the existing
+ * auto-reconnect scheduler brings the tabs back; nothing else to do here. */
+function askServerRestart(socket) {
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            pendingRepairs.delete(requestId);
+            resolve(describeRepairReply('timeout'));
+        }, REPAIR_TIMEOUT_MS);
+        pendingRepairs.set(requestId, (reply) => {
+            clearTimeout(timer);
+            resolve(describeRepairReply(reply));
+        });
+        send(socket, { kind: 'bridge.repair', request_id: requestId });
+    });
+}
+async function repairConnection() {
+    const socket = [...tabStates.values()]
+        .map((s) => s.ws)
+        .find((ws) => ws !== undefined && ws.readyState === WebSocket.OPEN);
+    const plan = planRepair({
+        connected: socket !== undefined,
+        serverVersion: getVersionCheck().server,
+        rememberedTabIds: await readRememberedTabIds(),
+    });
+    switch (plan.step) {
+        case 'ask-server-restart':
+            // `planRepair` only picks this step when a socket is open.
+            return socket ? askServerRestart(socket) : { ok: false, message: 'Not connected' };
+        case 'reconnect-only': {
+            // Same path as the popup's Connect: an explicit attempt replaces any
+            // pending auto-reconnect for the tab, and connectTab's per-tab lock
+            // turns a race with an in-flight retry into a benign result.
+            const results = await Promise.all(plan.tabIds.map(async (tabId) => {
+                reconnectScheduler.cancel(tabId);
+                try {
+                    return await connectTab(tabId);
+                }
+                catch {
+                    return { ok: false };
+                }
+            }));
+            return describeReconnectResults(results);
+        }
+        case 'manual':
+            return { ok: false, message: plan.message };
+    }
 }
 // === Flow recording by demonstration ===================================
 //
@@ -3304,6 +3458,12 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
         sendResponse(getVersionCheck());
         return false;
     }
+    if (msg.action === 'repairConnection') {
+        void repairConnection().then(sendResponse, (err) => {
+            sendResponse({ ok: false, message: err instanceof Error ? err.message : String(err) });
+        });
+        return true;
+    }
     if (msg.action === 'openActivityWindow') {
         void openActivityWindow().then(sendResponse);
         return true;
@@ -3316,6 +3476,14 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
         void purgeActivity(msg).then(sendResponse);
         return true;
     }
+    if (msg.action === 'adminDescribe') {
+        void adminDescribe().then(sendResponse);
+        return true;
+    }
+    if (msg.action === 'adminAction') {
+        void adminAction(msg).then(sendResponse);
+        return true;
+    }
     if (msg.action === 'recordingStatus') {
         sendResponse(getRecordingStatus(msg.tabId));
         return false;