ai-browser-profile 1.0.9 → 1.0.11

package/ai_browser_profile/cookies.py

@@ -143,6 +143,22 @@ def read_cookies(
         )
 
     domain_filters = list(domains) if domains else None
+
+    def _host_matches(host: str) -> bool:
+        # Domain-suffix match: 'x.com' matches 'x.com' / 'api.x.com' but not 'fedex.com'.
+        # Cookie host_keys often start with '.' for "all subdomains" — strip that.
+        h = host or ""
+        if "://" in h:
+            h = h.split("://", 1)[1]
+        h = h.split("/", 1)[0].split(":", 1)[0].lstrip(".").lower()
+        for f in (domain_filters or []):
+            ff = (f or "").strip().lstrip(".").lower()
+            if not ff:
+                continue
+            if h == ff or h.endswith("." + ff):
+                return True
+        return False
+
     key = _derive_key(_keychain_password(profile.browser))
     cookies: list[Cookie] = []
     skipped = 0
@@ -167,7 +183,7 @@ def read_cookies(
         )
         for row in rows:
             host = _txt(row["host_key"])
-            if domain_filters and not any(d in host for d in domain_filters):
+            if domain_filters and not _host_matches(host):
                 continue
             value = _txt(row["value"])
             if not value and row["encrypted_value"]:

package/ai_browser_profile/indexeddb.py

@@ -179,6 +179,21 @@ def read_indexeddb(
         [o.strip() for o in origins if o and o.strip()] if origins else None
     )
 
+    def _host_matches(origin: str) -> bool:
+        # Domain-suffix match: filter 'x.com' matches 'x.com' and
+        # 'api.x.com' but NOT 'fedex.com' / 'swiftpackageindex.com'.
+        h = origin or ""
+        if "://" in h:
+            h = h.split("://", 1)[1]
+        h = h.split("/", 1)[0].split(":", 1)[0].lstrip(".").lower()
+        for f in (origin_filter or []):
+            ff = (f or "").strip().lstrip(".").lower()
+            if not ff:
+                continue
+            if h == ff or h.endswith("." + ff):
+                return True
+        return False
+
     # Defaults to skip even when no explicit filter is given:
     #   chrome-extension://  — extensions, not portable across browsers
     #   localhost / 127.*    — dev servers, irrelevant across machines
@@ -211,7 +226,7 @@ def read_indexeddb(
         if origin is None:
             continue
         if origin_filter:
-            if not any(f in origin for f in origin_filter):
+            if not _host_matches(origin):
                 continue
         else:
             # No explicit filter — apply default safety skips.
@@ -442,12 +457,16 @@ def inject_indexeddb_via_cdp(
     cdp_url: str = "http://127.0.0.1:9655",
     load_wait_sec: float = 4.0,
 ) -> tuple[int, int]:
-    """Inject IndexedDB records into a running Chrome via per-origin tabs.
+    """Inject IndexedDB records into a running Chrome via a single reused tab.
 
-    Returns (written, total). For each origin we open a new tab at that
-    origin (so the JS context is same-origin), wait for initial load to let
-    the destination site bootstrap its own IDB schema, then run a single
-    Runtime.evaluate that replays all of our records.
+    Returns (written, total). Opens ONE tab at the start, hides it off-screen,
+    then navigates that same tab through each origin in sequence. For each
+    origin: navigate, wait for bootstrap, run a single Runtime.evaluate that
+    replays the IDB records via the standard JS API. Closes the tab at end.
+
+    This replaces the previous pattern of opening one visible tab per origin
+    (which produced a flood of tab open/close churn when many domains were in
+    the import list).
     """
     from websocket import create_connection
 
@@ -456,8 +475,46 @@ def inject_indexeddb_via_cdp(
     msg_id = 0
     total_records = 0
     total_written = 0
+    target_id: Optional[str] = None
+    session_id: Optional[str] = None
 
     try:
+        # Open ONE reusable tab. We start at about:blank and navigate it
+        # per origin below; reusing the tab is what eliminates the visible
+        # "open a tab per origin" UX issue when many domains are in scope.
+        msg_id += 1
+        r = _cdp_send(ws, msg_id, "Target.createTarget", {"url": "about:blank"})
+        target_id = r.get("result", {}).get("targetId")
+        if not target_id:
+            log.warning("createTarget(about:blank) failed: %s", r.get("error"))
+            return 0, 0
+
+        msg_id += 1
+        r = _cdp_send(ws, msg_id, "Target.attachToTarget",
+                      {"targetId": target_id, "flatten": True})
+        session_id = r.get("result", {}).get("sessionId")
+        if not session_id:
+            log.warning("attachToTarget(about:blank) failed: %s", r.get("error"))
+            return 0, 0
+
+        # Hide the import window off-screen so the user doesn't see it bounce
+        # through every origin. Best-effort.
+        try:
+            msg_id += 1
+            w = _cdp_send(ws, msg_id, "Browser.getWindowForTarget",
+                          {"targetId": target_id})
+            window_id = w.get("result", {}).get("windowId")
+            if window_id:
+                msg_id += 1
+                _cdp_send(ws, msg_id, "Browser.setWindowBounds", {
+                    "windowId": window_id,
+                    "bounds": {"left": -32000, "top": -32000,
+                               "width": 800, "height": 600,
+                               "windowState": "normal"},
+                })
+        except Exception as e:
+            log.debug("Could not hide import window: %s", e)
+
         for origin, dumps in data.items():
             if not dumps:
                 continue
@@ -474,84 +531,75 @@ def inject_indexeddb_via_cdp(
             total_records += origin_total
 
             url = origin.rstrip("/") + "/"
-            target_id = None
-            session_id = None
-            try:
-                msg_id += 1
-                r = _cdp_send(ws, msg_id, "Target.createTarget", {"url": url})
-                target_id = r.get("result", {}).get("targetId")
-                if not target_id:
-                    log.warning("Couldn't create tab for %s: %s", origin, r)
-                    continue
 
-                msg_id += 1
-                r = _cdp_send(ws, msg_id, "Target.attachToTarget",
-                              {"targetId": target_id, "flatten": True})
-                session_id = r.get("result", {}).get("sessionId")
-                if not session_id:
-                    log.warning("Couldn't attach to tab for %s: %s", origin, r)
-                    continue
+            # Navigate the SAME tab to this origin. No new tab is created.
+            msg_id += 1
+            nav = _cdp_send(ws, msg_id, "Page.navigate", {"url": url},
+                            session_id=session_id)
+            err = nav.get("result", {}).get("errorText") or nav.get("error")
+            if err:
+                log.warning("  %s: navigate failed (%s)", origin, err)
+                continue
 
-                # Let the destination site finish its initial bootstrap (it
-                # may create its own IDB schema with the canonical keyPath /
-                # version; we then add to it).
-                time.sleep(load_wait_sec)
-
-                # Serialize the data to JSON and inline into the JS expression.
-                # Records can be large; CDP accepts multi-MB expressions.
-                payload = {
-                    "dbs": [
-                        {
-                            "name": db.name,
-                            "stores": {
-                                sn: [{"key": r.key, "value": r.value} for r in recs]
-                                for sn, recs in db.stores.items()
-                            },
-                        }
-                        for db in dumps
-                    ]
-                }
-                expression = _INJECT_JS.replace("__PAYLOAD__", json.dumps(payload))
+            # Let the destination site finish its initial bootstrap (it may
+            # create its own IDB schema with the canonical keyPath/version;
+            # we then add to it).
+            time.sleep(load_wait_sec)
 
-                msg_id += 1
-                r = _cdp_send(
-                    ws, msg_id, "Runtime.evaluate",
+            # Serialize the data to JSON and inline into the JS expression.
+            # Records can be large; CDP accepts multi-MB expressions.
+            payload = {
+                "dbs": [
                     {
-                        "expression": expression,
-                        "awaitPromise": True,
-                        "returnByValue": True,
-                        "timeout": 60000,
-                    },
-                    session_id=session_id,
-                )
-                result = r.get("result", {}).get("result", {})
-                exc = r.get("result", {}).get("exceptionDetails")
-                if exc:
-                    log.warning("  %s: JS error %s", origin, exc.get("text") or exc)
-                    continue
-                value = result.get("value")
-                try:
-                    summary = json.loads(value).get("summary", []) if isinstance(value, str) else []
-                except Exception:
-                    summary = []
-                origin_written = 0
-                for s in summary:
-                    if s.get("opened"):
-                        origin_written += s.get("written", 0)
-                        if s.get("errored"):
-                            log.warning("  %s/%s: %d errored", origin, s.get("db"), s.get("errored"))
-                    else:
-                        log.warning("  %s/%s: open failed (%s)", origin, s.get("db"), s.get("error"))
-                total_written += origin_written
-                log.info("  %s: wrote %d/%d records", origin, origin_written, origin_total)
-            finally:
-                if target_id:
-                    try:
-                        msg_id += 1
-                        _cdp_send(ws, msg_id, "Target.closeTarget", {"targetId": target_id})
-                    except Exception:
-                        pass
+                        "name": db.name,
+                        "stores": {
+                            sn: [{"key": r.key, "value": r.value} for r in recs]
+                            for sn, recs in db.stores.items()
+                        },
+                    }
+                    for db in dumps
+                ]
+            }
+            expression = _INJECT_JS.replace("__PAYLOAD__", json.dumps(payload))
+
+            msg_id += 1
+            r = _cdp_send(
+                ws, msg_id, "Runtime.evaluate",
+                {
+                    "expression": expression,
+                    "awaitPromise": True,
+                    "returnByValue": True,
+                    "timeout": 60000,
+                },
+                session_id=session_id,
+            )
+            result = r.get("result", {}).get("result", {})
+            exc = r.get("result", {}).get("exceptionDetails")
+            if exc:
+                log.warning("  %s: JS error %s", origin, exc.get("text") or exc)
+                continue
+            value = result.get("value")
+            try:
+                summary = json.loads(value).get("summary", []) if isinstance(value, str) else []
+            except Exception:
+                summary = []
+            origin_written = 0
+            for s in summary:
+                if s.get("opened"):
+                    origin_written += s.get("written", 0)
+                    if s.get("errored"):
+                        log.warning("  %s/%s: %d errored", origin, s.get("db"), s.get("errored"))
+                else:
+                    log.warning("  %s/%s: open failed (%s)", origin, s.get("db"), s.get("error"))
+            total_written += origin_written
+            log.info("  %s: wrote %d/%d records", origin, origin_written, origin_total)
     finally:
+        if target_id:
+            try:
+                msg_id += 1
+                _cdp_send(ws, msg_id, "Target.closeTarget", {"targetId": target_id})
+            except Exception:
+                pass
         ws.close()
 
     log.info("Injected %d/%d IndexedDB records total", total_written, total_records)

package/ai_browser_profile/localstorage.py

@@ -33,6 +33,29 @@ from ai_browser_profile.cookies import _ws_from_cdp_url, find_profile
 log = logging.getLogger(__name__)
 
 
+def _host_matches(host: str, filters: list[str]) -> bool:
+    """Domain-suffix match: filter 'x.com' matches 'x.com' and 'sub.x.com',
+    but NOT 'fedex.com' or 'swiftpackageindex.com'.
+
+    Accepts either a raw host like 'example.com' or a full origin like
+    'https://example.com' / 'https://example.com:8080'.
+    """
+    if not host:
+        return False
+    h = host
+    if "://" in h:
+        h = h.split("://", 1)[1]
+    h = h.split("/", 1)[0].split(":", 1)[0]  # strip path and port
+    h = h.lstrip(".").lower()
+    for f in filters:
+        ff = f.strip().lstrip(".").lower()
+        if not ff:
+            continue
+        if h == ff or h.endswith("." + ff):
+            return True
+    return False
+
+
 def read_localstorage(
     profile: BrowserProfile,
     origins: Optional[Iterable[str]] = None,
@@ -77,7 +100,7 @@ def read_localstorage(
                 value = record.value
                 if not origin or not key or value is None:
                     continue
-                if origin_filters and not any(f in origin for f in origin_filters):
+                if origin_filters and not _host_matches(origin, origin_filters):
                     continue
                 if isinstance(value, bytes):
                     try:
@@ -125,19 +148,23 @@ def inject_localstorage_via_cdp(
     cdp_url: str = "http://127.0.0.1:9222",
     load_wait_sec: float = 4.0,
 ) -> int:
-    """Inject localStorage into a running Chrome via per-origin tabs.
+    """Inject localStorage into a running Chrome by reusing a single hidden tab.
+
+    Opens ONE tab at the start, hides it off-screen, then navigates that same
+    tab through each origin in sequence to run a localStorage.setItem batch in
+    the page's JS context. Closes the tab at the end. Returns total items
+    written.
 
-    For each origin: opens a new tab to that origin (so the JS context is
-    same-origin), waits for load, evaluates a localStorage.setItem batch via
-    Runtime.evaluate, then closes the tab. Returns total items written.
+    This replaces the previous pattern of opening one visible tab per origin
+    (which produced a flood of tab open/close churn when many domains were in
+    the import list).
 
     Args:
         data: dict of {origin -> {key: value}}. Origin must be http(s)://...
         cdp_url: base http(s) URL of the Chrome DevTools endpoint or a
                  cdp://host:port shorthand.
-        load_wait_sec: how long to wait between tab open and the JS eval to
-                       let the page initialize (no Page.loadEventFired listener
-                       yet — keep simple, race-tolerant via the JS try/catch).
+        load_wait_sec: seconds to wait after navigating between origins before
+                       injecting (lets the destination page initialize).
     """
     from websocket import create_connection
 
@@ -145,8 +172,47 @@ def inject_localstorage_via_cdp(
     ws = create_connection(ws_url, timeout=15, suppress_origin=True)
     msg_id = 0
     total_set = 0
+    target_id: Optional[str] = None
+    session_id: Optional[str] = None
 
     try:
+        # Open ONE reusable tab. We start at about:blank and navigate it
+        # per origin below; reusing the tab is what eliminates the visible
+        # "29 tabs flashing open" UX issue.
+        msg_id += 1
+        r = _cdp_send(ws, msg_id, "Target.createTarget", {"url": "about:blank"})
+        target_id = r.get("result", {}).get("targetId")
+        if not target_id:
+            log.warning("createTarget(about:blank) failed: %s", r.get("error"))
+            return 0
+
+        msg_id += 1
+        r = _cdp_send(ws, msg_id, "Target.attachToTarget",
+                      {"targetId": target_id, "flatten": True})
+        session_id = r.get("result", {}).get("sessionId")
+        if not session_id:
+            log.warning("attachToTarget(about:blank) failed: %s", r.get("error"))
+            return 0
+
+        # Move the tab's window way off-screen so the user doesn't see it
+        # bounce through every origin. Best-effort; some Chrome builds reject
+        # negative window bounds, in which case we just stay on-screen.
+        try:
+            msg_id += 1
+            w = _cdp_send(ws, msg_id, "Browser.getWindowForTarget",
+                          {"targetId": target_id})
+            window_id = w.get("result", {}).get("windowId")
+            if window_id:
+                msg_id += 1
+                _cdp_send(ws, msg_id, "Browser.setWindowBounds", {
+                    "windowId": window_id,
+                    "bounds": {"left": -32000, "top": -32000,
+                               "width": 800, "height": 600,
+                               "windowState": "normal"},
+                })
+        except Exception as e:
+            log.debug("Could not hide import window: %s", e)
+
         for origin, items in data.items():
             if not items:
                 continue
@@ -162,53 +228,44 @@ def inject_localstorage_via_cdp(
                 continue
             url = origin.rstrip("/") + "/"
 
-            target_id = None
-            try:
-                msg_id += 1
-                r = _cdp_send(ws, msg_id, "Target.createTarget", {"url": url})
-                target_id = r.get("result", {}).get("targetId")
-                if not target_id:
-                    log.warning("createTarget failed for %s: %s", origin, r.get("error"))
-                    continue
-
-                msg_id += 1
-                r = _cdp_send(ws, msg_id, "Target.attachToTarget",
-                              {"targetId": target_id, "flatten": True})
-                session_id = r.get("result", {}).get("sessionId")
-                if not session_id:
-                    log.warning("attachToTarget failed for %s", origin)
-                    continue
-
-                time.sleep(load_wait_sec)
+            # Navigate the SAME tab to this origin. No new tab is created.
+            msg_id += 1
+            nav = _cdp_send(ws, msg_id, "Page.navigate", {"url": url},
+                            session_id=session_id)
+            err = nav.get("result", {}).get("errorText") or nav.get("error")
+            if err:
+                log.warning("  %s: navigate failed (%s)", origin, err)
+                continue
 
-                # Inline the items as a JS object literal; localStorage rejects
-                # non-string values implicitly by coercion (we already string-
-                # coerced in read_localstorage).
-                expr = (
-                    "(function(){try{var items=" + json.dumps(items) + ";"
-                    "var n=0;for(var k in items){try{localStorage.setItem(k,items[k]);n++;}catch(e){}}"
-                    "return n;}catch(e){return 'ERROR:'+e.toString();}})()"
-                )
-                msg_id += 1
-                r = _cdp_send(
-                    ws, msg_id, "Runtime.evaluate",
-                    {"expression": expr, "returnByValue": True},
-                    session_id=session_id,
-                )
-                value = r.get("result", {}).get("result", {}).get("value")
-                if isinstance(value, int):
-                    total_set += value
-                    log.info("  %s: set %d/%d items", origin, value, len(items))
-                else:
-                    log.warning("  %s: %s", origin, value)
-            finally:
-                if target_id:
-                    try:
-                        msg_id += 1
-                        _cdp_send(ws, msg_id, "Target.closeTarget", {"targetId": target_id})
-                    except Exception:
-                        pass
+            time.sleep(load_wait_sec)
+
+            # Inline the items as a JS object literal; localStorage rejects
+            # non-string values implicitly by coercion (we already string-
+            # coerced in read_localstorage).
+            expr = (
+                "(function(){try{var items=" + json.dumps(items) + ";"
+                "var n=0;for(var k in items){try{localStorage.setItem(k,items[k]);n++;}catch(e){}}"
+                "return n;}catch(e){return 'ERROR:'+e.toString();}})()"
+            )
+            msg_id += 1
+            r = _cdp_send(
+                ws, msg_id, "Runtime.evaluate",
+                {"expression": expr, "returnByValue": True},
+                session_id=session_id,
+            )
+            value = r.get("result", {}).get("result", {}).get("value")
+            if isinstance(value, int):
+                total_set += value
+                log.info("  %s: set %d/%d items", origin, value, len(items))
+            else:
+                log.warning("  %s: %s", origin, value)
     finally:
+        if target_id:
+            try:
+                msg_id += 1
+                _cdp_send(ws, msg_id, "Target.closeTarget", {"targetId": target_id})
+            except Exception:
+                pass
         ws.close()
 
     log.info("Injected %d localStorage items total", total_set)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-browser-profile",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Extract user identity (name, emails, accounts, addresses, payments) from browser data into a self-ranking SQLite database. Install as a Claude Code agent skill.",
   "bin": {
     "ai-browser-profile": "bin/cli.js"