tabctl 0.6.0-rc.2 → 0.6.0-rc.3

package/README.md

@@ -167,6 +167,11 @@ tabctl query '{ reportTabs(windowId: 123) { entries { tabId title url descriptio
 # Capture screenshots
 tabctl query 'query { captureScreenshots(tabIds: [456], mode: "viewport") { entries { tabId tiles { index width height } } } }'
 
+# Inspect persisted browser-state history for future restore tooling
+tabctl query 'query { latestBrowserState { snapshotId reason groups { logicalGroupId title browserGroupId tabUrls } } }'
+tabctl query 'query { browserStateHistory(limit: 10) { snapshotId recordedAt reason eventCount eventKinds } }'
+tabctl query 'query { browserStateGroupHistory(title: "Research", limit: 10) { snapshotId logicalGroupId title browserGroupId tabUrls } }'
+
 # Open tabs in a new grouped window
 tabctl query 'mutation { openTabs(urls: ["https://example.com"], group: "Research", newWindow: true) { windowId groupId tabs { tabId url } } }'
 
@@ -227,6 +232,7 @@ See [CLI.md](CLI.md#configuration) for full details.
 ## Runtime state
 - Socket: `<dataDir>/tabctl.sock` (default: `~/.local/state/tabctl/tabctl.sock`)
 - Undo log: `<dataDir>/undo.jsonl` (default: `~/.local/state/tabctl/undo.jsonl`)
+- Browser-state history DB: `<dataDir>/state.db` (default: `~/.local/state/tabctl/state.db`)
 - Profile registry: `<configDir>/profiles.json`
 - WSL TCP port file: `<dataDir>/tcp-port` (written by the Windows host)
 

package/dist/extension/background.js

@@ -475,6 +475,7 @@
   };
   var KEEPALIVE_ALARM = "tabctl-keepalive";
   var KEEPALIVE_INTERVAL_MINUTES = 1;
+  var BROWSER_STATE_SYNC_DEBOUNCE_MS = 750;
   var screenshot = require_screenshot();
   var content = require_content();
   var { delay, executeWithTimeout } = content;
@@ -488,6 +489,14 @@
   var state = {
     port: null
   };
+  var browserState = {
+    nextId: 1,
+    syncTimer: null,
+    pendingEvents: [],
+    incognitoWindowIds: /* @__PURE__ */ new Set(),
+    incognitoTabIds: /* @__PURE__ */ new Set(),
+    incognitoGroupIds: /* @__PURE__ */ new Set()
+  };
   function log(...args) {
     console.log("[tabctl]", ...args);
   }
@@ -521,10 +530,221 @@
         state.port = null;
       });
       log("Native host connected");
+      queueBrowserStateSync("startup");
     } catch (error) {
       log("Native host connection failed", error);
     }
   }
+  function nextBrowserStateId() {
+    const id = browserState.nextId;
+    browserState.nextId += 1;
+    return `browser-state-${Date.now()}-${id}`;
+  }
+  function normalizeEventPayload(kind, payload) {
+    const event = {
+      kind,
+      occurredAt: Date.now()
+    };
+    for (const [key, value] of Object.entries(payload)) {
+      if (value === void 0) {
+        continue;
+      }
+      event[key] = value;
+    }
+    if (event.incognito !== true && inferIncognitoEvent(payload)) {
+      event.incognito = true;
+    }
+    return event;
+  }
+  function inferIncognitoEvent(payload) {
+    const tabId = typeof payload.tabId === "number" ? payload.tabId : null;
+    if (tabId !== null && browserState.incognitoTabIds.has(tabId)) {
+      return true;
+    }
+    const groupId = typeof payload.groupId === "number" ? payload.groupId : null;
+    if (groupId !== null && browserState.incognitoGroupIds.has(groupId)) {
+      return true;
+    }
+    const windowId = typeof payload.windowId === "number" ? payload.windowId : null;
+    return windowId !== null && browserState.incognitoWindowIds.has(windowId);
+  }
+  function updateIncognitoState(snapshot) {
+    browserState.incognitoWindowIds.clear();
+    browserState.incognitoTabIds.clear();
+    browserState.incognitoGroupIds.clear();
+    for (const window2 of snapshot.windows || []) {
+      if (window2.incognito !== true || typeof window2.windowId !== "number") {
+        continue;
+      }
+      browserState.incognitoWindowIds.add(window2.windowId);
+      for (const tab of window2.tabs || []) {
+        if (typeof tab.tabId === "number") {
+          browserState.incognitoTabIds.add(tab.tabId);
+        }
+      }
+      for (const group of window2.groups || []) {
+        if (typeof group.groupId === "number") {
+          browserState.incognitoGroupIds.add(group.groupId);
+        }
+      }
+    }
+  }
+  async function postBrowserStateSync(reason) {
+    if (!state.port) {
+      return;
+    }
+    const eventCount = browserState.pendingEvents.length;
+    const events = browserState.pendingEvents.slice(0, eventCount);
+    try {
+      const snapshot = await getTabSnapshot();
+      updateIncognitoState(snapshot);
+      state.port.postMessage({
+        id: nextBrowserStateId(),
+        action: "browser-state-sync",
+        ok: true,
+        data: {
+          reason,
+          recordedAt: Date.now(),
+          events,
+          snapshot
+        }
+      });
+      browserState.pendingEvents.splice(0, eventCount);
+    } catch (error) {
+      log("Browser state sync failed", error);
+    }
+  }
+  function queueBrowserStateSync(reason) {
+    if (!state.port) {
+      connectNative();
+      return;
+    }
+    if (browserState.syncTimer) {
+      clearTimeout(browserState.syncTimer);
+    }
+    const delayMs = reason === "startup" ? 0 : BROWSER_STATE_SYNC_DEBOUNCE_MS;
+    browserState.syncTimer = setTimeout(() => {
+      browserState.syncTimer = null;
+      void postBrowserStateSync(reason);
+    }, delayMs);
+  }
+  function enqueueBrowserStateEvent(kind, payload, reason = "event") {
+    browserState.pendingEvents.push(normalizeEventPayload(kind, payload));
+    queueBrowserStateSync(reason);
+  }
+  function registerBrowserStateListeners() {
+    chrome.tabs?.onCreated?.addListener((tab) => {
+      enqueueBrowserStateEvent("tabs.onCreated", {
+        tabId: tab.id,
+        windowId: tab.windowId,
+        groupId: tab.groupId,
+        incognito: tab.incognito,
+        url: tab.url,
+        title: tab.title,
+        index: tab.index
+      });
+    });
+    chrome.tabs?.onUpdated?.addListener((tabId, changeInfo, tab) => {
+      const interesting = ["url", "title", "status", "pinned", "audible", "discarded", "favIconUrl"];
+      if (!interesting.some((key) => key in changeInfo)) {
+        return;
+      }
+      enqueueBrowserStateEvent("tabs.onUpdated", {
+        tabId,
+        windowId: tab.windowId,
+        groupId: tab.groupId,
+        incognito: tab.incognito,
+        changeInfo
+      });
+    });
+    chrome.tabs?.onMoved?.addListener((tabId, moveInfo) => {
+      enqueueBrowserStateEvent("tabs.onMoved", {
+        tabId,
+        windowId: moveInfo.windowId,
+        fromIndex: moveInfo.fromIndex,
+        toIndex: moveInfo.toIndex
+      });
+    });
+    chrome.tabs?.onAttached?.addListener((tabId, attachInfo) => {
+      enqueueBrowserStateEvent("tabs.onAttached", {
+        tabId,
+        windowId: attachInfo.newWindowId,
+        newPosition: attachInfo.newPosition
+      });
+    });
+    chrome.tabs?.onDetached?.addListener((tabId, detachInfo) => {
+      enqueueBrowserStateEvent("tabs.onDetached", {
+        tabId,
+        windowId: detachInfo.oldWindowId,
+        oldPosition: detachInfo.oldPosition
+      });
+    });
+    chrome.tabs?.onRemoved?.addListener((tabId, removeInfo) => {
+      enqueueBrowserStateEvent("tabs.onRemoved", {
+        tabId,
+        windowId: removeInfo.windowId,
+        isWindowClosing: removeInfo.isWindowClosing
+      });
+    });
+    chrome.tabs?.onActivated?.addListener((activeInfo) => {
+      enqueueBrowserStateEvent("tabs.onActivated", {
+        tabId: activeInfo.tabId,
+        windowId: activeInfo.windowId
+      });
+    });
+    chrome.tabGroups?.onCreated?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onCreated", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onUpdated?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onUpdated", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onMoved?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onMoved", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onRemoved?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onRemoved", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.windows?.onCreated?.addListener((window2) => {
+      enqueueBrowserStateEvent("windows.onCreated", {
+        windowId: window2.id,
+        incognito: window2.incognito,
+        focused: window2.focused,
+        state: window2.state
+      });
+    });
+    chrome.windows?.onRemoved?.addListener((windowId) => {
+      enqueueBrowserStateEvent("windows.onRemoved", { windowId });
+    });
+    chrome.windows?.onFocusChanged?.addListener((windowId) => {
+      enqueueBrowserStateEvent("windows.onFocusChanged", { windowId });
+    });
+  }
+  connectNative();
+  registerBrowserStateListeners();
   chrome.runtime.onInstalled.addListener(() => {
     connectNative();
     chrome.alarms.create(KEEPALIVE_ALARM, { periodInMinutes: KEEPALIVE_INTERVAL_MINUTES });
@@ -656,6 +876,7 @@
           tabId: tab.id,
           windowId: win.id,
           index: tab.index,
+          incognito: win.incognito || false,
           url: tab.url,
           title: tab.title,
           active: tab.active,
@@ -680,6 +901,7 @@
       return {
         windowId: win.id,
         focused: win.focused,
+        incognito: win.incognito || false,
         state: win.state,
         tabs,
         groups: windowGroups

package/dist/extension/manifest.json

@@ -19,5 +19,5 @@
   "background": {
     "service_worker": "background.js"
   },
-  "version_name": "0.6.0-rc.2"
+  "version_name": "0.6.0-rc.3"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.6.0-rc.2",
+  "version": "0.6.0-rc.3",
   "description": "CLI tool to manage and analyze browser tabs",
   "license": "MIT",
   "repository": {