tabctl 0.6.0-rc.10 → 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;
@@ -795,6 +800,10 @@
   var ACTIVE_PAGE_CACHE_STATUS_TIMEOUT_MS = 3e4;
   var CACHE_AVAILABLE_BADGE_TEXT = "C";
   var CACHE_AVAILABLE_BADGE_COLOR = "#2da44e";
+  var CACHE_WAITING_BADGE_TEXT = "W";
+  var CACHE_WAITING_BADGE_COLOR = "#bf8700";
+  var CACHE_ERROR_BADGE_TEXT = "E";
+  var CACHE_ERROR_BADGE_COLOR = "#cf222e";
   var RECONNECT_INITIAL_DELAY_MS = 250;
   var RECONNECT_MAX_DELAY_MS = 3e4;
   var RECONNECT_ALARM_MIN_DELAY_MS = 3e4;
@@ -832,7 +841,16 @@
     lastCapturedKey: null,
     lastQuiescentCapturedKey: null,
     lastQuiescentCapturedAt: 0,
-    statusRequests: /* @__PURE__ */ new Map()
+    statusRequests: /* @__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);
@@ -969,6 +987,9 @@
   function activePageCacheKey(tab, url) {
     return `${tab.id}:${url}`;
   }
+  function activePageCacheKeyForTabId(tabId, url) {
+    return `${tabId}:${url}`;
+  }
   function activePageCacheUrl(tab) {
     return tab.url || tab.pendingUrl || "";
   }
@@ -987,19 +1008,84 @@
       log("clear cache indicator failed", { tabId, error });
     }
   }
-  async function setCacheAvailableIndicator(tabId, expectedUrl) {
+  async function setCacheBadgeIndicator(tabId, expectedUrl, text, color, title) {
     try {
       const tab = await chrome.tabs.get(tabId);
       if (!isEligibleActivePageCacheTab(tab) || activePageCacheUrl(tab) !== expectedUrl) {
         await clearCacheAvailableIndicator(tabId);
         return;
       }
-      await chrome.action?.setBadgeBackgroundColor?.({ tabId, color: CACHE_AVAILABLE_BADGE_COLOR });
-      await chrome.action?.setBadgeText?.({ tabId, text: CACHE_AVAILABLE_BADGE_TEXT });
-      await chrome.action?.setTitle?.({ tabId, title: "Tab Control - page cache available" });
+      await chrome.action?.setBadgeBackgroundColor?.({ tabId, color });
+      await chrome.action?.setBadgeText?.({ tabId, text });
+      await chrome.action?.setTitle?.({ tabId, title });
     } catch (error) {
-      log("set cache indicator failed", { tabId, error });
+      log("set cache indicator failed", { tabId, text, error });
+    }
+  }
+  async function setCacheAvailableIndicator(tabId, expectedUrl) {
+    await setCacheBadgeIndicator(
+      tabId,
+      expectedUrl,
+      CACHE_AVAILABLE_BADGE_TEXT,
+      CACHE_AVAILABLE_BADGE_COLOR,
+      "Tab Control - page cache available"
+    );
+  }
+  async function setCacheWaitingIndicator(tabId, expectedUrl, detail) {
+    await setCacheBadgeIndicator(
+      tabId,
+      expectedUrl,
+      CACHE_WAITING_BADGE_TEXT,
+      CACHE_WAITING_BADGE_COLOR,
+      `Tab Control - waiting for page cache (${detail})`
+    );
+  }
+  async function setCacheErrorIndicator(tabId, expectedUrl, detail) {
+    await setCacheBadgeIndicator(
+      tabId,
+      expectedUrl,
+      CACHE_ERROR_BADGE_TEXT,
+      CACHE_ERROR_BADGE_COLOR,
+      `Tab Control - page cache error (${detail})`
+    );
+  }
+  function hasPendingActivePageCacheWork(tabId, url) {
+    const key = activePageCacheKeyForTabId(tabId, url);
+    return activePageCache.inFlightKeys.has(key) || activePageCache.pending?.key === key || activePageCache.quiescentPending?.key === key;
+  }
+  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 clearActivePageCacheState(tabId, url) {
+    activePageCache.states.delete(activePageCacheKeyForTabId(tabId, url));
+  }
+  function clearActivePageCacheStatesForTab(tabId) {
+    const prefix = `${tabId}:`;
+    for (const key of activePageCache.states.keys()) {
+      if (key.startsWith(prefix)) {
+        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 {
@@ -1007,10 +1093,31 @@
       if (activePageCacheUrl(tab) !== expectedUrl) {
         return;
       }
-      if (!isEligibleActivePageCacheTab(tab) || !available) {
+      if (!isEligibleActivePageCacheTab(tab)) {
         await clearCacheAvailableIndicator(tabId);
         return;
       }
+      if (!available) {
+        const cacheState = activePageCacheState(tabId, expectedUrl);
+        const waitingDetail = waitingDetailForActivePageCacheState(cacheState);
+        if (waitingDetail) {
+          await setCacheWaitingIndicator(tabId, expectedUrl, waitingDetail);
+          return;
+        }
+        if (cacheState?.kind === "error") {
+          await setCacheErrorIndicator(tabId, expectedUrl, cacheState.detail);
+          return;
+        }
+        if (hasPendingActivePageCacheWork(tabId, expectedUrl)) {
+          setActivePageCacheState(tabId, expectedUrl, "capturing");
+          await setCacheWaitingIndicator(tabId, expectedUrl, ACTIVE_PAGE_CACHE_STATE_DETAILS.capturing);
+          return;
+        }
+        clearActivePageCacheState(tabId, expectedUrl);
+        await clearCacheAvailableIndicator(tabId);
+        return;
+      }
+      setActivePageCacheState(tabId, expectedUrl, "cached");
       await setCacheAvailableIndicator(tabId, expectedUrl);
     } catch {
       await clearCacheAvailableIndicator(tabId);
@@ -1044,7 +1151,8 @@
     const port = state.port;
     if (!port) {
       connectNative();
-      void clearCacheAvailableIndicator(tab.id);
+      setActivePageCacheState(tab.id, url, "checking", "native host reconnecting");
+      void setCacheWaitingIndicator(tab.id, url, "native host reconnecting");
       return;
     }
     const id = nextActivePageCacheStatusId();
@@ -1096,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) {
@@ -1135,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") {
@@ -1144,23 +1263,27 @@
       clearPendingQuiescentActivePageCacheCapture();
       return;
     }
-    requestPageCacheStatus(tab, reason);
     const url = activePageCacheUrl(tab);
     const key = activePageCacheKey(tab, url);
+    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 {
@@ -1195,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;
@@ -1221,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,
@@ -1241,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);
@@ -1250,8 +1453,42 @@
       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", {
+          tabId: captureTab.id,
+          reason,
+          key,
+          status: extraction.status,
+          error: extraction.error,
+          sourceHtmlChars: extraction.sourceHtmlChars,
+          sourceTextChars: extraction.sourceTextChars,
+          documentReadyState: extraction.documentReadyState,
+          truncatedHtml: extraction.truncatedHtml
+        });
+        if (extraction.status === "NOT_LOADED") {
+          const url = activePageCacheUrl(captureTab);
+          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);
+          setActivePageCacheState(captureTab.id, url, "error", detail);
+          void setCacheErrorIndicator(captureTab.id, url, detail);
+        }
         void requestPageCacheStatusForTab(captureTab.id, `${reason}:capture-failed`);
         return false;
       }
@@ -1263,6 +1500,7 @@
       if (!port) {
         return false;
       }
+      const openTabs = await getPageCacheOpenTabs();
       const id = nextActivePageCacheId();
       trackPageCacheStatusRequest(id, verifiedTab.id, activePageCacheUrl(verifiedTab));
       port.postMessage({
@@ -1272,6 +1510,7 @@
         data: {
           reason,
           capturedAt: Date.now(),
+          openTabs,
           tab: {
             tabId: verifiedTab.id,
             windowId: verifiedTab.windowId,
@@ -1294,6 +1533,9 @@
       return true;
     } catch (error) {
       log("active page cache capture failed", { tabId: tab.id, reason, error });
+      const url = activePageCacheUrl(tab);
+      setActivePageCacheState(tab.id, url, "error", "capture exception");
+      void setCacheErrorIndicator(tab.id, url, "capture exception");
       void requestPageCacheStatusForTab(tab.id, `${reason}:capture-error`);
       return false;
     } finally {
@@ -1417,6 +1659,7 @@
         changeInfo
       });
       if ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo) {
+        clearActivePageCacheStatesForTab(tabId);
         void clearCacheAvailableIndicator(tabId);
       }
       if (tab.active && ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo)) {
@@ -1456,6 +1699,7 @@
           activePageCache.statusRequests.delete(requestId);
         }
       });
+      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.10"
+  "version_name": "0.6.0-rc.12"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.6.0-rc.10",
+  "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.10"
+    "tabctl-win32-x64": "0.6.0-rc.12"
   },
   "dependencies": {
     "normalize-url": "^8.1.1"