tabctl 0.6.0-rc.11 → 0.6.0-rc.12

package/dist/extension/background.js

@@ -783,7 +783,12 @@
   var RECONNECT_ALARM = "tabctl-reconnect";
   var KEEPALIVE_INTERVAL_MINUTES = 1;
   var BROWSER_STATE_SYNC_DEBOUNCE_MS = 750;
-  var ACTIVE_PAGE_CACHE_DEBOUNCE_MS = 1e3;
+  var ACTIVE_PAGE_CACHE_LOADING_RETRY_MS = 100;
+  var ACTIVE_PAGE_CACHE_SETTLING_RETRY_MS = 150;
+  var ACTIVE_PAGE_CACHE_FIRST_QUIESCENT_TIMEOUT_MS = 750;
+  var ACTIVE_PAGE_CACHE_FIRST_QUIESCENT_SAMPLE_MS = 75;
+  var ACTIVE_PAGE_CACHE_FIRST_LOADING_MAX_ATTEMPTS = 300;
+  var ACTIVE_PAGE_CACHE_FIRST_SETTLING_MAX_ATTEMPTS = 200;
   var ACTIVE_PAGE_CACHE_TIMEOUT_MS = 5e3;
   var MAX_PAGE_HTML_CHARS = 10 * 1024 * 1024;
   var ACTIVE_PAGE_CACHE_MAX_HTML_CHARS = MAX_PAGE_HTML_CHARS;
@@ -837,7 +842,15 @@
     lastQuiescentCapturedKey: null,
     lastQuiescentCapturedAt: 0,
     statusRequests: /* @__PURE__ */ new Map(),
-    diagnostics: /* @__PURE__ */ new Map()
+    states: /* @__PURE__ */ new Map()
+  };
+  var ACTIVE_PAGE_CACHE_STATE_DETAILS = {
+    checking: "checking status",
+    loading: "page still loading",
+    settling: "waiting for page settle",
+    capturing: "capture pending",
+    cached: "page cache available",
+    error: "capture failed"
   };
   function log(...args) {
     console.log("[tabctl]", ...args);
@@ -1040,20 +1053,40 @@
     const key = activePageCacheKeyForTabId(tabId, url);
     return activePageCache.inFlightKeys.has(key) || activePageCache.pending?.key === key || activePageCache.quiescentPending?.key === key;
   }
-  function setActivePageCacheDiagnostic(tabId, url, kind, detail) {
-    activePageCache.diagnostics.set(activePageCacheKeyForTabId(tabId, url), { kind, detail });
+  function setActivePageCacheState(tabId, url, kind, detail = ACTIVE_PAGE_CACHE_STATE_DETAILS[kind]) {
+    activePageCache.states.set(activePageCacheKeyForTabId(tabId, url), { kind, detail });
+  }
+  function activePageCacheState(tabId, url) {
+    return activePageCache.states.get(activePageCacheKeyForTabId(tabId, url));
   }
-  function clearActivePageCacheDiagnostic(tabId, url) {
-    activePageCache.diagnostics.delete(activePageCacheKeyForTabId(tabId, url));
+  function clearActivePageCacheState(tabId, url) {
+    activePageCache.states.delete(activePageCacheKeyForTabId(tabId, url));
   }
-  function clearActivePageCacheDiagnosticsForTab(tabId) {
+  function clearActivePageCacheStatesForTab(tabId) {
     const prefix = `${tabId}:`;
-    for (const key of activePageCache.diagnostics.keys()) {
+    for (const key of activePageCache.states.keys()) {
       if (key.startsWith(prefix)) {
-        activePageCache.diagnostics.delete(key);
+        activePageCache.states.delete(key);
       }
     }
   }
+  function clearPendingFirstActivePageCacheCapture(key) {
+    if (activePageCache.pending?.key === key) {
+      activePageCache.pending = null;
+    }
+  }
+  function failFirstActivePageCacheCapture(pending, tab, url, detail) {
+    clearPendingFirstActivePageCacheCapture(pending.key);
+    setActivePageCacheState(tab.id, url, "error", detail);
+    void setCacheErrorIndicator(tab.id, url, detail);
+    void requestPageCacheStatusForTab(tab.id, `first-capture:${detail.replace(/\s+/g, "-")}`);
+  }
+  function waitingDetailForActivePageCacheState(state2) {
+    if (state2?.kind === "checking" || state2?.kind === "loading" || state2?.kind === "settling" || state2?.kind === "capturing") {
+      return state2.detail;
+    }
+    return null;
+  }
   async function applyPageCacheStatus(tabId, expectedUrl, available) {
     try {
       const tab = await chrome.tabs.get(tabId);
@@ -1065,23 +1098,26 @@
         return;
       }
       if (!available) {
-        const diagnostic = activePageCache.diagnostics.get(activePageCacheKeyForTabId(tabId, expectedUrl));
-        if (diagnostic?.kind === "waiting") {
-          await setCacheWaitingIndicator(tabId, expectedUrl, diagnostic.detail);
+        const cacheState = activePageCacheState(tabId, expectedUrl);
+        const waitingDetail = waitingDetailForActivePageCacheState(cacheState);
+        if (waitingDetail) {
+          await setCacheWaitingIndicator(tabId, expectedUrl, waitingDetail);
           return;
         }
-        if (diagnostic?.kind === "error") {
-          await setCacheErrorIndicator(tabId, expectedUrl, diagnostic.detail);
+        if (cacheState?.kind === "error") {
+          await setCacheErrorIndicator(tabId, expectedUrl, cacheState.detail);
           return;
         }
         if (hasPendingActivePageCacheWork(tabId, expectedUrl)) {
-          await setCacheWaitingIndicator(tabId, expectedUrl, "capture pending");
+          setActivePageCacheState(tabId, expectedUrl, "capturing");
+          await setCacheWaitingIndicator(tabId, expectedUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.capturing);
           return;
         }
+        clearActivePageCacheState(tabId, expectedUrl);
         await clearCacheAvailableIndicator(tabId);
         return;
       }
-      clearActivePageCacheDiagnostic(tabId, expectedUrl);
+      setActivePageCacheState(tabId, expectedUrl, "cached");
       await setCacheAvailableIndicator(tabId, expectedUrl);
     } catch {
       await clearCacheAvailableIndicator(tabId);
@@ -1115,6 +1151,7 @@
     const port = state.port;
     if (!port) {
       connectNative();
+      setActivePageCacheState(tab.id, url, "checking", "native host reconnecting");
       void setCacheWaitingIndicator(tab.id, url, "native host reconnecting");
       return;
     }
@@ -1167,7 +1204,7 @@
   }
   function isEligibleActivePageCacheTab(tab) {
     const url = activePageCacheUrl(tab);
-    return typeof tab.id === "number" && Boolean(url) && tab.incognito !== true && !browserState.incognitoTabIds.has(tab.id) && (typeof tab.windowId !== "number" || !browserState.incognitoWindowIds.has(tab.windowId)) && tab.discarded !== true && tab.status !== "loading" && isScriptableUrl(url);
+    return typeof tab.id === "number" && Boolean(url) && tab.incognito !== true && !browserState.incognitoTabIds.has(tab.id) && (typeof tab.windowId !== "number" || !browserState.incognitoWindowIds.has(tab.windowId)) && tab.discarded !== true && isScriptableUrl(url);
   }
   function clearPendingActivePageCacheCapture() {
     if (activePageCache.timer) {
@@ -1206,6 +1243,17 @@
       }
     }, ACTIVE_PAGE_CACHE_QUIESCENT_DELAY_MS);
   }
+  function scheduleFirstActivePageCacheRetry(pending, delayMs) {
+    clearPendingActivePageCacheCapture();
+    activePageCache.pending = pending;
+    activePageCache.timer = setTimeout(() => {
+      activePageCache.timer = null;
+      const retry = activePageCache.pending;
+      if (retry) {
+        void captureFirstSettledActivePageCache(retry);
+      }
+    }, delayMs);
+  }
   function scheduleActivePageCacheCapture(tab, reason) {
     if (!isEligibleActivePageCacheTab(tab)) {
       if (typeof tab.id === "number") {
@@ -1217,23 +1265,25 @@
     }
     const url = activePageCacheUrl(tab);
     const key = activePageCacheKey(tab, url);
-    clearActivePageCacheDiagnostic(tab.id, url);
-    void setCacheWaitingIndicator(tab.id, url, "checking status");
+    if (tab.status === "loading") {
+      setActivePageCacheState(tab.id, url, "loading");
+      void setCacheWaitingIndicator(tab.id, url, ACTIVE_PAGE_CACHE_STATE_DETAILS.loading);
+      if (activePageCache.pending?.key !== key) {
+        scheduleFirstActivePageCacheRetry({ tabId: tab.id, reason, key, attempts: 0 }, ACTIVE_PAGE_CACHE_LOADING_RETRY_MS);
+      }
+      return;
+    }
+    setActivePageCacheState(tab.id, url, "checking");
+    void setCacheWaitingIndicator(tab.id, url, ACTIVE_PAGE_CACHE_STATE_DETAILS.checking);
     requestPageCacheStatus(tab, reason);
     scheduleQuiescentActivePageCacheCapture(tab, reason, key);
     if (activePageCache.inFlightKeys.has(key) || activePageCache.lastCapturedKey === key) {
       return;
     }
-    clearPendingActivePageCacheCapture();
-    activePageCache.pending = { tab, reason, key };
-    activePageCache.timer = setTimeout(() => {
-      activePageCache.timer = null;
-      const pending = activePageCache.pending;
-      activePageCache.pending = null;
-      if (pending) {
-        void captureActivePageCache(pending.tab, pending.reason, pending.key);
-      }
-    }, ACTIVE_PAGE_CACHE_DEBOUNCE_MS);
+    if (activePageCache.pending?.key === key) {
+      return;
+    }
+    scheduleFirstActivePageCacheRetry({ tabId: tab.id, reason, key, attempts: 0 }, 0);
   }
   async function scheduleActivePageCacheCaptureForTab(tabId, reason) {
     try {
@@ -1268,6 +1318,83 @@
       return null;
     }
   }
+  async function getPageCacheOpenTabs() {
+    const tabs = await chrome.tabs.query({});
+    return tabs.filter((tab) => typeof tab.id === "number").filter((tab) => tab.incognito !== true).map((tab) => ({ tabId: tab.id, url: activePageCacheUrl(tab) })).filter((tab) => tab.url.length > 0 && isScriptableUrl(tab.url));
+  }
+  async function captureFirstSettledActivePageCache(pending) {
+    if (activePageCache.inFlightKeys.has(pending.key) || activePageCache.lastCapturedKey === pending.key) {
+      if (activePageCache.pending?.key === pending.key) {
+        activePageCache.pending = null;
+      }
+      return;
+    }
+    const tab = await currentActivePageCacheTab(pending.tabId, pending.key);
+    if (!tab) {
+      if (activePageCache.pending?.key === pending.key) {
+        activePageCache.pending = null;
+      }
+      return;
+    }
+    const tabUrl = activePageCacheUrl(tab);
+    if (tab.status === "loading") {
+      setActivePageCacheState(tab.id, tabUrl, "loading");
+      void setCacheWaitingIndicator(tab.id, tabUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.loading);
+      if (pending.attempts < ACTIVE_PAGE_CACHE_FIRST_LOADING_MAX_ATTEMPTS) {
+        scheduleFirstActivePageCacheRetry(
+          { ...pending, attempts: pending.attempts + 1 },
+          ACTIVE_PAGE_CACHE_LOADING_RETRY_MS
+        );
+      } else {
+        failFirstActivePageCacheCapture(pending, tab, tabUrl, "loading attempts exhausted");
+      }
+      return;
+    }
+    setActivePageCacheState(tab.id, tabUrl, "settling");
+    void setCacheWaitingIndicator(tab.id, tabUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.settling);
+    const probe = await content.probePageQuiescence(
+      tab.id,
+      ACTIVE_PAGE_CACHE_FIRST_QUIESCENT_TIMEOUT_MS,
+      ACTIVE_PAGE_CACHE_FIRST_QUIESCENT_SAMPLE_MS
+    );
+    if (activePageCache.pending?.key !== pending.key) {
+      return;
+    }
+    if (!probe.quiet) {
+      if (probe.error || probe.documentReadyState === null) {
+        failFirstActivePageCacheCapture(
+          pending,
+          tab,
+          tabUrl,
+          probe.reason || "page settle probe failed"
+        );
+        return;
+      }
+      const loading = probe.documentReadyState !== "interactive" && probe.documentReadyState !== "complete";
+      setActivePageCacheState(tab.id, tabUrl, loading ? "loading" : "settling");
+      void setCacheWaitingIndicator(
+        tab.id,
+        tabUrl,
+        loading ? ACTIVE_PAGE_CACHE_STATE_DETAILS.loading : ACTIVE_PAGE_CACHE_STATE_DETAILS.settling
+      );
+      if (pending.attempts < ACTIVE_PAGE_CACHE_FIRST_SETTLING_MAX_ATTEMPTS) {
+        scheduleFirstActivePageCacheRetry(
+          { ...pending, attempts: pending.attempts + 1 },
+          loading ? ACTIVE_PAGE_CACHE_LOADING_RETRY_MS : ACTIVE_PAGE_CACHE_SETTLING_RETRY_MS
+        );
+      } else {
+        failFirstActivePageCacheCapture(
+          pending,
+          tab,
+          tabUrl,
+          loading ? "loading attempts exhausted" : "settling attempts exhausted"
+        );
+      }
+      return;
+    }
+    clearPendingFirstActivePageCacheCapture(pending.key);
+    await captureActivePageCache(tab, pending.reason, pending.key);
+  }
   async function rescheduleQuiescentActivePageCacheCapture(pending) {
     if (pending.attempts >= 2 || isQuiescentCaptureCoolingDown(pending.key)) {
       return;
@@ -1294,6 +1421,9 @@
     if (!tab) {
       return;
     }
+    const tabUrl = activePageCacheUrl(tab);
+    setActivePageCacheState(tab.id, tabUrl, "settling");
+    void setCacheWaitingIndicator(tab.id, tabUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.settling);
     const probe = await content.probePageQuiescence(
       tab.id,
       ACTIVE_PAGE_CACHE_QUIESCENT_TIMEOUT_MS,
@@ -1314,7 +1444,7 @@
       connectNative();
       return false;
     }
-    if (!isEligibleActivePageCacheTab(tab) || activePageCache.inFlightKeys.has(key)) {
+    if (!isEligibleActivePageCacheTab(tab) || tab.status === "loading" || activePageCache.inFlightKeys.has(key)) {
       return false;
     }
     activePageCache.inFlightKeys.add(key);
@@ -1323,6 +1453,15 @@
       if (!captureTab) {
         return false;
       }
+      const captureUrl = activePageCacheUrl(captureTab);
+      if (captureTab.status === "loading") {
+        setActivePageCacheState(captureTab.id, captureUrl, "loading");
+        void setCacheWaitingIndicator(captureTab.id, captureUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.loading);
+        scheduleFirstActivePageCacheRetry({ tabId: captureTab.id, reason, key, attempts: 0 }, ACTIVE_PAGE_CACHE_LOADING_RETRY_MS);
+        return false;
+      }
+      setActivePageCacheState(captureTab.id, captureUrl, "capturing");
+      void setCacheWaitingIndicator(captureTab.id, captureUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.capturing);
       const extraction = await content.extractPageHtml(captureTab.id, ACTIVE_PAGE_CACHE_TIMEOUT_MS, ACTIVE_PAGE_CACHE_MAX_HTML_CHARS);
       if (extraction.status !== "READ" || typeof extraction.html !== "string" || extraction.html.length === 0) {
         log("active page cache extraction not readable", {
@@ -1338,12 +1477,16 @@
         });
         if (extraction.status === "NOT_LOADED") {
           const url = activePageCacheUrl(captureTab);
-          setActivePageCacheDiagnostic(captureTab.id, url, "waiting", "page still loading");
-          void setCacheWaitingIndicator(captureTab.id, url, "page still loading");
+          setActivePageCacheState(captureTab.id, url, "loading");
+          void setCacheWaitingIndicator(captureTab.id, url, ACTIVE_PAGE_CACHE_STATE_DETAILS.loading);
+          scheduleFirstActivePageCacheRetry(
+            { tabId: captureTab.id, reason, key, attempts: 0 },
+            ACTIVE_PAGE_CACHE_LOADING_RETRY_MS
+          );
         } else {
           const detail = typeof extraction.status === "string" ? extraction.status.toLowerCase().replace(/_/g, " ") : "capture failed";
           const url = activePageCacheUrl(captureTab);
-          setActivePageCacheDiagnostic(captureTab.id, url, "error", detail);
+          setActivePageCacheState(captureTab.id, url, "error", detail);
           void setCacheErrorIndicator(captureTab.id, url, detail);
         }
         void requestPageCacheStatusForTab(captureTab.id, `${reason}:capture-failed`);
@@ -1357,6 +1500,7 @@
       if (!port) {
         return false;
       }
+      const openTabs = await getPageCacheOpenTabs();
       const id = nextActivePageCacheId();
       trackPageCacheStatusRequest(id, verifiedTab.id, activePageCacheUrl(verifiedTab));
       port.postMessage({
@@ -1366,6 +1510,7 @@
         data: {
           reason,
           capturedAt: Date.now(),
+          openTabs,
           tab: {
             tabId: verifiedTab.id,
             windowId: verifiedTab.windowId,
@@ -1389,7 +1534,7 @@
     } catch (error) {
       log("active page cache capture failed", { tabId: tab.id, reason, error });
       const url = activePageCacheUrl(tab);
-      setActivePageCacheDiagnostic(tab.id, url, "error", "capture exception");
+      setActivePageCacheState(tab.id, url, "error", "capture exception");
       void setCacheErrorIndicator(tab.id, url, "capture exception");
       void requestPageCacheStatusForTab(tab.id, `${reason}:capture-error`);
       return false;
@@ -1514,7 +1659,7 @@
         changeInfo
       });
       if ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo) {
-        clearActivePageCacheDiagnosticsForTab(tabId);
+        clearActivePageCacheStatesForTab(tabId);
         void clearCacheAvailableIndicator(tabId);
       }
       if (tab.active && ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo)) {
@@ -1554,7 +1699,7 @@
           activePageCache.statusRequests.delete(requestId);
         }
       });
-      clearActivePageCacheDiagnosticsForTab(tabId);
+      clearActivePageCacheStatesForTab(tabId);
       void clearCacheAvailableIndicator(tabId);
     });
     chrome.tabs?.onActivated?.addListener((activeInfo) => {

package/dist/extension/manifest.json

@@ -22,5 +22,5 @@
   "action": {
     "default_title": "Tab Control"
   },
-  "version_name": "0.6.0-rc.11"
+  "version_name": "0.6.0-rc.12"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.6.0-rc.11",
+  "version": "0.6.0-rc.12",
   "description": "CLI tool to manage and analyze browser tabs",
   "license": "MIT",
   "repository": {
@@ -53,7 +53,7 @@
     "typescript": "^5.4.5"
   },
   "optionalDependencies": {
-    "tabctl-win32-x64": "0.6.0-rc.11"
+    "tabctl-win32-x64": "0.6.0-rc.12"
   },
   "dependencies": {
     "normalize-url": "^8.1.1"