tabctl 0.6.0-rc.10 → 0.6.0-rc.11

package/dist/extension/background.js

@@ -795,6 +795,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 +836,8 @@
     lastCapturedKey: null,
     lastQuiescentCapturedKey: null,
     lastQuiescentCapturedAt: 0,
-    statusRequests: /* @__PURE__ */ new Map()
+    statusRequests: /* @__PURE__ */ new Map(),
+    diagnostics: /* @__PURE__ */ new Map()
   };
   function log(...args) {
     console.log("[tabctl]", ...args);
@@ -969,6 +974,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,18 +995,63 @@
       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 setActivePageCacheDiagnostic(tabId, url, kind, detail) {
+    activePageCache.diagnostics.set(activePageCacheKeyForTabId(tabId, url), { kind, detail });
+  }
+  function clearActivePageCacheDiagnostic(tabId, url) {
+    activePageCache.diagnostics.delete(activePageCacheKeyForTabId(tabId, url));
+  }
+  function clearActivePageCacheDiagnosticsForTab(tabId) {
+    const prefix = `${tabId}:`;
+    for (const key of activePageCache.diagnostics.keys()) {
+      if (key.startsWith(prefix)) {
+        activePageCache.diagnostics.delete(key);
+      }
     }
   }
   async function applyPageCacheStatus(tabId, expectedUrl, available) {
@@ -1007,10 +1060,28 @@
       if (activePageCacheUrl(tab) !== expectedUrl) {
         return;
       }
-      if (!isEligibleActivePageCacheTab(tab) || !available) {
+      if (!isEligibleActivePageCacheTab(tab)) {
         await clearCacheAvailableIndicator(tabId);
         return;
       }
+      if (!available) {
+        const diagnostic = activePageCache.diagnostics.get(activePageCacheKeyForTabId(tabId, expectedUrl));
+        if (diagnostic?.kind === "waiting") {
+          await setCacheWaitingIndicator(tabId, expectedUrl, diagnostic.detail);
+          return;
+        }
+        if (diagnostic?.kind === "error") {
+          await setCacheErrorIndicator(tabId, expectedUrl, diagnostic.detail);
+          return;
+        }
+        if (hasPendingActivePageCacheWork(tabId, expectedUrl)) {
+          await setCacheWaitingIndicator(tabId, expectedUrl, "capture pending");
+          return;
+        }
+        await clearCacheAvailableIndicator(tabId);
+        return;
+      }
+      clearActivePageCacheDiagnostic(tabId, expectedUrl);
       await setCacheAvailableIndicator(tabId, expectedUrl);
     } catch {
       await clearCacheAvailableIndicator(tabId);
@@ -1044,7 +1115,7 @@
     const port = state.port;
     if (!port) {
       connectNative();
-      void clearCacheAvailableIndicator(tab.id);
+      void setCacheWaitingIndicator(tab.id, url, "native host reconnecting");
       return;
     }
     const id = nextActivePageCacheStatusId();
@@ -1144,9 +1215,11 @@
       clearPendingQuiescentActivePageCacheCapture();
       return;
     }
-    requestPageCacheStatus(tab, reason);
     const url = activePageCacheUrl(tab);
     const key = activePageCacheKey(tab, url);
+    clearActivePageCacheDiagnostic(tab.id, url);
+    void setCacheWaitingIndicator(tab.id, url, "checking status");
+    requestPageCacheStatus(tab, reason);
     scheduleQuiescentActivePageCacheCapture(tab, reason, key);
     if (activePageCache.inFlightKeys.has(key) || activePageCache.lastCapturedKey === key) {
       return;
@@ -1252,6 +1325,27 @@
       }
       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);
+          setActivePageCacheDiagnostic(captureTab.id, url, "waiting", "page still loading");
+          void setCacheWaitingIndicator(captureTab.id, url, "page still loading");
+        } else {
+          const detail = typeof extraction.status === "string" ? extraction.status.toLowerCase().replace(/_/g, " ") : "capture failed";
+          const url = activePageCacheUrl(captureTab);
+          setActivePageCacheDiagnostic(captureTab.id, url, "error", detail);
+          void setCacheErrorIndicator(captureTab.id, url, detail);
+        }
         void requestPageCacheStatusForTab(captureTab.id, `${reason}:capture-failed`);
         return false;
       }
@@ -1294,6 +1388,9 @@
       return true;
     } catch (error) {
       log("active page cache capture failed", { tabId: tab.id, reason, error });
+      const url = activePageCacheUrl(tab);
+      setActivePageCacheDiagnostic(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 +1514,7 @@
         changeInfo
       });
       if ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo) {
+        clearActivePageCacheDiagnosticsForTab(tabId);
         void clearCacheAvailableIndicator(tabId);
       }
       if (tab.active && ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo)) {
@@ -1456,6 +1554,7 @@
           activePageCache.statusRequests.delete(requestId);
         }
       });
+      clearActivePageCacheDiagnosticsForTab(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.11"
 }

package/package.json

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