ai-browser-profile 1.0.5

package/ai_browser_profile/ingestors/constants.py

@@ -0,0 +1,208 @@
+"""Lookup maps and browser paths for memory extraction. Self-contained, no external imports."""
+
+import re
+
+from pathlib import Path
+
+APP_SUPPORT = Path.home() / "Library" / "Application Support"
+
+# Chromium address_type_tokens type codes -> (key_name, tags)
+ADDRESS_TYPE_MAP = {
+    3: ("first_name", ["identity"]),
+    5: ("last_name", ["identity"]),
+    7: ("full_name", ["identity"]),
+    9: ("email", ["identity", "email", "communication"]),
+    14: ("phone", ["identity", "phone", "communication"]),
+    33: ("city", ["address", "location"]),
+    34: ("state", ["address", "location"]),
+    35: ("zip", ["address", "location"]),
+    36: ("country", ["address", "location"]),
+    60: ("company", ["identity", "company", "work"]),
+    77: ("street_address", ["address", "location"]),
+    79: ("address_line_2", ["address", "location"]),
+}
+
+# Autofill form field names -> (normalized key, tags)
+# Used for normalization — unmapped fields are still ingested under cleaned names
+AUTOFILL_FIELD_MAP = {
+    "email": ("email", ["identity", "email", "communication"]),
+    "e-mail": ("email", ["identity", "email", "communication"]),
+    "email_address": ("email", ["identity", "email", "communication"]),
+    "emailaddress": ("email", ["identity", "email", "communication"]),
+    "email-form-field": ("email", ["identity", "email", "communication"]),
+    "name": ("full_name", ["identity"]),
+    "fullname": ("full_name", ["identity"]),
+    "full_name": ("full_name", ["identity"]),
+    "full-name": ("full_name", ["identity"]),
+    "firstname": ("first_name", ["identity"]),
+    "first_name": ("first_name", ["identity"]),
+    "first-name": ("first_name", ["identity"]),
+    "given-name": ("first_name", ["identity"]),
+    "lastname": ("last_name", ["identity"]),
+    "last_name": ("last_name", ["identity"]),
+    "last-name": ("last_name", ["identity"]),
+    "family-name": ("last_name", ["identity"]),
+    "phone": ("phone", ["identity", "phone", "communication"]),
+    "tel": ("phone", ["identity", "phone", "communication"]),
+    "telephone": ("phone", ["identity", "phone", "communication"]),
+    "mobile": ("phone", ["identity", "phone", "communication"]),
+    "phonenumber": ("phone", ["identity", "phone", "communication"]),
+    "phone_number": ("phone", ["identity", "phone", "communication"]),
+    "mobilenumber": ("phone", ["identity", "phone", "communication"]),
+    "city": ("city", ["address", "location"]),
+    "state": ("state", ["address", "location"]),
+    "zip": ("zip", ["address", "location"]),
+    "zipcode": ("zip", ["address", "location"]),
+    "postal": ("zip", ["address", "location"]),
+    "postalcode": ("zip", ["address", "location"]),
+    "postal_code": ("zip", ["address", "location"]),
+    "country": ("country", ["address", "location"]),
+    "address": ("street_address", ["address", "location"]),
+    "street": ("street_address", ["address", "location"]),
+    "address1": ("street_address", ["address", "location"]),
+    "company": ("company", ["identity", "company", "work"]),
+    "companyname": ("company", ["identity", "company", "work"]),
+    "company_name": ("company", ["identity", "company", "work"]),
+    "organization": ("company", ["identity", "company", "work"]),
+    "username": ("username", ["identity", "account", "credential"]),
+    "login": ("username", ["identity", "account", "credential"]),
+    "identifier": ("username", ["identity", "account", "credential"]),
+    "dob": ("date_of_birth", ["identity"]),
+    "dateofbirth": ("date_of_birth", ["identity"]),
+    "date_of_birth": ("date_of_birth", ["identity"]),
+    "date-of-birth": ("date_of_birth", ["identity"]),
+    "birth-date": ("date_of_birth", ["identity"]),
+    "birthdate": ("date_of_birth", ["identity"]),
+    "birthday": ("date_of_birth", ["identity"]),
+    "gender": ("gender", ["identity"]),
+    "sex": ("gender", ["identity"]),
+}
+
+# Keywords in field names → tags (for unmapped fields)
+TAG_KEYWORDS = {
+    "identity": ["birth", "dob", "gender", "sex", "name", "first", "last", "middle", "suffix",
+                  "passport", "nationality", "citizen", "ssn"],
+    "travel": ["travel", "flyer", "frequent", "airline", "seat", "meal", "tsa",
+               "known_traveler", "traveler", "passenger", "boarding", "flight", "loyalty"],
+    "address": ["address", "street", "city", "state", "zip", "postal", "country", "apt"],
+    "payment": ["card", "payment", "billing", "cvv", "expir"],
+    "communication": ["email", "phone", "tel", "mobile", "fax"],
+    "account": ["username", "login", "password", "account"],
+    "work": ["company", "organization", "employer", "job", "title", "occupation"],
+}
+
+# Regex for noise detection in field names
+_UUID_RE = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-')
+_PURE_DIGITS_RE = re.compile(r'^\d+$')
+_TIMESTAMP_RE = re.compile(r'^\d{10,}$')
+_SELECTOR_RE = re.compile(r'^(selectors\.|role:|#\d)')
+_CELL_RE = re.compile(r'^cell[-_]\d+[-_]\d+', re.IGNORECASE)
+_INTERNAL_RE = re.compile(r'^(react_aria|emoji_popover|_\drif_|docs_findandreplace|input\d+_\d+|single_line_text_form_component|single_typeahead_entity_form_component)')
+_MONTH_YEAR_RE = re.compile(r'^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d{4}$', re.IGNORECASE)
+
+
+def clean_field_name(raw: str) -> str:
+    """Normalize a raw autofill field name to a clean key.
+
+    Examples:
+        'rtiTraveler.travelers[0].firstName' → 'firstname'
+        'dateofbirth-mercury-utils-id-304' → 'dateofbirth'
+        '1-date_of_birth' → 'date_of_birth'
+        'BirthDayM' → 'birthdaym'
+    """
+    field = raw.strip()
+    # Extract last segment of dotted paths
+    if "." in field:
+        field = field.rsplit(".", 1)[-1]
+    # Strip array indices
+    field = re.sub(r'\[\d+\]', '', field)
+    # Strip leading numeric prefixes like "1-" or "0-1/"
+    field = re.sub(r'^[\d]+-', '', field)
+    field = re.sub(r'^[\d]+-[\d]+/', '', field)
+    # Strip trailing ID suffixes like "-mercury-utils-id-304"
+    field = re.sub(r'-[a-z]+-[a-z]+-[a-z]+-\d+$', '', field)
+    # Lowercase
+    field = field.lower().strip()
+    # Replace separators with underscore for lookup
+    normalized = re.sub(r'[-/]', '_', field)
+    return normalized
+
+
+def is_noise_field(raw: str) -> bool:
+    """Return True if the field name is noise (UUIDs, timestamps, selectors, spreadsheet cells)."""
+    return bool(
+        _UUID_RE.match(raw)
+        or _PURE_DIGITS_RE.match(raw)
+        or _TIMESTAMP_RE.match(raw)
+        or _SELECTOR_RE.match(raw)
+        or _CELL_RE.match(raw)
+        or _INTERNAL_RE.match(raw)
+        or _MONTH_YEAR_RE.match(raw)
+    )
+
+
+def infer_tags(field: str) -> list[str]:
+    """Infer tags from a cleaned field name using keyword matching."""
+    tags = set()
+    for tag, keywords in TAG_KEYWORDS.items():
+        for kw in keywords:
+            if kw in field:
+                tags.add(tag)
+                break
+    if not tags:
+        tags.add("autofill")
+    return list(tags)
+
+# Domains -> friendly service names for tool/account detection
+SERVICE_NAMES = {
+    "github.com": "GitHub", "gitlab.com": "GitLab", "stackoverflow.com": "Stack Overflow",
+    "figma.com": "Figma", "notion.so": "Notion", "trello.com": "Trello",
+    "slack.com": "Slack", "app.slack.com": "Slack",
+    "linear.app": "Linear", "vercel.com": "Vercel", "netlify.com": "Netlify",
+    "aws.amazon.com": "AWS", "console.cloud.google.com": "GCP",
+    "portal.azure.com": "Azure", "chatgpt.com": "ChatGPT", "chat.openai.com": "ChatGPT",
+    "claude.ai": "Claude", "console.anthropic.com": "Anthropic Console",
+    "docs.google.com": "Google Docs", "sheets.google.com": "Google Sheets",
+    "drive.google.com": "Google Drive", "mail.google.com": "Gmail",
+    "calendar.google.com": "Google Calendar", "meet.google.com": "Google Meet",
+    "twitter.com": "X/Twitter", "x.com": "X/Twitter",
+    "linkedin.com": "LinkedIn", "www.linkedin.com": "LinkedIn",
+    "instagram.com": "Instagram", "www.instagram.com": "Instagram",
+    "facebook.com": "Facebook", "www.facebook.com": "Facebook",
+    "reddit.com": "Reddit", "www.reddit.com": "Reddit",
+    "youtube.com": "YouTube", "www.youtube.com": "YouTube",
+    "open.spotify.com": "Spotify",
+    "dashboard.stripe.com": "Stripe", "stripe.com": "Stripe",
+    "supabase.com": "Supabase",
+    "firebase.google.com": "Firebase",
+    "sentry.io": "Sentry",
+    "posthog.com": "PostHog", "us.posthog.com": "PostHog",
+    "mixpanel.com": "Mixpanel",
+    "app.apollo.io": "Apollo",
+    "quickbooks.intuit.com": "QuickBooks",
+    "web.whatsapp.com": "WhatsApp",
+    "discord.com": "Discord",
+    "teams.microsoft.com": "Microsoft Teams",
+    "canva.com": "Canva", "www.canva.com": "Canva",
+    "excalidraw.com": "Excalidraw",
+    "codesandbox.io": "CodeSandbox",
+    "codepen.io": "CodePen",
+    "app.cal.com": "Cal.com",
+    "calendly.com": "Calendly",
+    "my.openphone.com": "OpenPhone",
+    "mail.missiveapp.com": "Missive",
+    "app.gusto.com": "Gusto",
+    "coinbase.com": "Coinbase", "www.coinbase.com": "Coinbase",
+    "polymarket.com": "Polymarket",
+    "producthunt.com": "Product Hunt", "www.producthunt.com": "Product Hunt",
+    "upwork.com": "Upwork", "www.upwork.com": "Upwork",
+    "fiverr.com": "Fiverr", "www.fiverr.com": "Fiverr",
+}
+
+# Chromium browser data directories
+BROWSER_PATHS = {
+    "arc": APP_SUPPORT / "Arc" / "User Data",
+    "chrome": APP_SUPPORT / "Google" / "Chrome",
+    "brave": APP_SUPPORT / "BraveSoftware" / "Brave-Browser",
+    "edge": APP_SUPPORT / "Microsoft Edge",
+}

package/ai_browser_profile/ingestors/history.py

@@ -0,0 +1,123 @@
+"""Ingest tool/service memories from browser history."""
+
+import shutil
+import sqlite3
+import logging
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile, copy_db, domain
+from ai_browser_profile.ingestors.constants import SERVICE_NAMES
+
+log = logging.getLogger(__name__)
+
+CHROME_EPOCH = datetime(1601, 1, 1, tzinfo=timezone.utc)
+MACOS_EPOCH = datetime(2001, 1, 1, tzinfo=timezone.utc)
+
+
+def _chromium_history(profile: BrowserProfile) -> dict[str, int]:
+    """Read domain visit counts from Chromium History SQLite."""
+    counts: dict[str, int] = {}
+    tmp = copy_db(profile.path / "History")
+    if not tmp:
+        return counts
+    try:
+        conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        for row in conn.execute(
+            "SELECT url, visit_count FROM urls ORDER BY last_visit_time DESC LIMIT 10000"
+        ):
+            d = domain(row["url"])
+            if d:
+                counts[d] = counts.get(d, 0) + (row["visit_count"] or 1)
+        conn.close()
+    except Exception as e:
+        log.warning(f"Failed to read History for {profile.browser}/{profile.name}: {e}")
+    finally:
+        shutil.rmtree(tmp.parent, ignore_errors=True)
+    return counts
+
+
+def _safari_history(profile: BrowserProfile) -> dict[str, int]:
+    """Read domain visit counts from Safari History.db."""
+    counts: dict[str, int] = {}
+    tmp = copy_db(profile.path / "History.db")
+    if not tmp:
+        return counts
+    try:
+        conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        for row in conn.execute(
+            "SELECT url, visit_count FROM history_items ORDER BY visit_count DESC LIMIT 10000"
+        ):
+            d = domain(row["url"])
+            if d:
+                counts[d] = counts.get(d, 0) + (row["visit_count"] or 1)
+        conn.close()
+    except Exception as e:
+        log.warning(f"Failed to read Safari History: {e}")
+    finally:
+        shutil.rmtree(tmp.parent, ignore_errors=True)
+    return counts
+
+
+def _firefox_history(profile: BrowserProfile) -> dict[str, int]:
+    """Read domain visit counts from Firefox places.sqlite."""
+    counts: dict[str, int] = {}
+    tmp = copy_db(profile.path / "places.sqlite")
+    if not tmp:
+        return counts
+    try:
+        conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        for row in conn.execute(
+            "SELECT url, visit_count FROM moz_places WHERE visit_count > 0 ORDER BY visit_count DESC LIMIT 10000"
+        ):
+            d = domain(row["url"])
+            if d:
+                counts[d] = counts.get(d, 0) + (row["visit_count"] or 1)
+        conn.close()
+    except Exception as e:
+        log.warning(f"Failed to read Firefox places.sqlite: {e}")
+    finally:
+        shutil.rmtree(tmp.parent, ignore_errors=True)
+    return counts
+
+
+def ingest_history(mem: MemoryDB, profiles: list[BrowserProfile]):
+    """Extract tool/service memories from browser history across all profiles."""
+    # Aggregate domain counts across all profiles
+    totals: dict[str, int] = {}
+    for profile in profiles:
+        if profile.browser in ("arc", "chrome", "brave", "edge"):
+            counts = _chromium_history(profile)
+        elif profile.browser == "safari":
+            counts = _safari_history(profile)
+        elif profile.browser == "firefox":
+            counts = _firefox_history(profile)
+        else:
+            continue
+        for d, c in counts.items():
+            totals[d] = totals.get(d, 0) + c
+
+    # Convert to tool/service memories
+    for d, total in sorted(totals.items(), key=lambda x: -x[1])[:200]:
+        if d not in SERVICE_NAMES:
+            continue
+        service = SERVICE_NAMES[d]
+        tags = ["account", "tool"]
+        if service in ("GitHub", "GitLab", "Vercel", "Netlify", "Supabase", "Firebase", "CodeSandbox"):
+            tags.append("work")
+            tags.append("dev")
+        elif service in ("Gmail", "Slack", "WhatsApp", "Discord", "Microsoft Teams", "Missive", "OpenPhone"):
+            tags.append("communication")
+        elif service in ("LinkedIn", "X/Twitter", "Instagram", "Facebook", "Reddit", "YouTube", "Product Hunt"):
+            tags.append("social")
+        elif service in ("Stripe", "QuickBooks", "Coinbase", "Gusto", "Polymarket"):
+            tags.append("finance")
+        elif service in ("ChatGPT", "Claude", "Anthropic Console"):
+            tags.append("ai")
+        mem.upsert(f"tool:{service}", str(total), tags, source=f"history:{d}")
+
+    log.info(f"  History: {len(totals)} domains, {sum(1 for d in totals if d in SERVICE_NAMES)} known services")

package/ai_browser_profile/ingestors/indexeddb.py

@@ -0,0 +1,203 @@
+"""Ingest WhatsApp contacts from Chromium IndexedDB (LevelDB)."""
+
+import json
+import shutil
+import tempfile
+import logging
+from pathlib import Path
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile
+
+log = logging.getLogger(__name__)
+
+
+def _copy_dir(src: Path) -> Path:
+    """Copy a directory to temp to avoid browser locks."""
+    tmp = Path(tempfile.mkdtemp(prefix="ai_browser_profile_idb_"))
+    dst = tmp / src.name
+    shutil.copytree(src, dst)
+    return dst
+
+
+def _serialize_value(val, depth=0):
+    """Recursively convert ccl IndexedDB value to JSON-safe dict."""
+    if depth > 20:
+        return "<nested too deep>"
+    if val is None:
+        return None
+    if isinstance(val, (bool, int, float, str)):
+        return val
+    if isinstance(val, bytes):
+        try:
+            return val.decode("utf-8")
+        except UnicodeDecodeError:
+            return f"<binary {len(val)} bytes>"
+    if isinstance(val, dict):
+        return {str(k): _serialize_value(v, depth + 1) for k, v in val.items()}
+    if isinstance(val, (list, tuple)):
+        return [_serialize_value(v, depth + 1) for v in val]
+    if hasattr(val, "value"):
+        return _serialize_value(val.value, depth + 1)
+    return str(val)
+
+
+def _normalize_phone(raw: str) -> str:
+    """Normalize a phone number to digits-only with leading +."""
+    digits = "".join(c for c in raw if c.isdigit())
+    if not digits:
+        return raw
+    if not digits.startswith("+"):
+        digits = "+" + digits
+    return digits
+
+
+def _extract_phone(data: dict) -> str:
+    """Extract and normalize a phone number from a WhatsApp contact record."""
+    phone = data.get("phoneNumber") or ""
+    jid = data.get("id") or ""
+
+    if not phone and "@" in str(jid):
+        # Extract digits from JID (works for both @c.us and @s.whatsapp.net)
+        phone = str(jid).split("@")[0]
+
+    if phone:
+        return _normalize_phone(phone)
+    return ""
+
+
+def ingest_indexeddb(mem: MemoryDB, profiles: list[BrowserProfile]):
+    """Extract WhatsApp contacts from Chromium IndexedDB.
+
+    Deduplicates contacts by normalized phone number — WhatsApp stores each
+    contact under both @c.us and @s.whatsapp.net JIDs, which previously
+    inflated the database by ~44%.
+    """
+    from ccl_chromium_reader import ccl_chromium_indexeddb
+
+    # Collect all contacts first, dedup by (name, phone)
+    seen: dict[tuple[str, str], dict] = {}  # (name, phone) -> {tags, value}
+
+    for profile in profiles:
+        if profile.browser in ("safari", "firefox"):
+            continue
+
+        idb_root = profile.path / "IndexedDB"
+        if not idb_root.exists():
+            continue
+
+        for db_dir in sorted(idb_root.glob("*whatsapp*_0.indexeddb.leveldb")):
+            blob_dir = db_dir.parent / db_dir.name.replace(".leveldb", ".blob")
+
+            tmp_db = _copy_dir(db_dir)
+            tmp_blob = _copy_dir(blob_dir) if blob_dir.exists() else None
+
+            try:
+                wrapper = ccl_chromium_indexeddb.WrappedIndexDB(
+                    str(tmp_db),
+                    str(tmp_blob) if tmp_blob else None,
+                )
+
+                for db_id in wrapper.database_ids:
+                    try:
+                        db = wrapper[db_id.name, db_id.origin]
+                    except Exception:
+                        continue
+
+                    if "contact" not in db.object_store_names:
+                        continue
+
+                    for record in db["contact"].iterate_records():
+                        try:
+                            data = _serialize_value(record.value)
+                            if not isinstance(data, dict):
+                                continue
+
+                            name = data.get("name") or data.get("pushname") or data.get("verifiedName") or ""
+                            if not name:
+                                continue
+
+                            # Skip junk names
+                            stripped = name.strip()
+                            if not stripped or stripped == "." or stripped == "<Undefined>":
+                                continue
+                            # Skip emoji-only names (no alphanumeric chars)
+                            if not any(c.isalnum() for c in stripped):
+                                continue
+
+                            phone = _extract_phone(data)
+                            jid = data.get("id") or ""
+
+                            tags = ["contact", "communication"]
+                            if data.get("isBusiness") or data.get("isEnterprise"):
+                                tags.append("work")
+
+                            value = phone if phone else str(jid)
+                            dedup_key = (name, phone if phone else str(jid))
+
+                            if dedup_key not in seen:
+                                seen[dedup_key] = {"tags": tags, "value": value}
+                            else:
+                                # Merge tags (e.g. one record has "work", the other doesn't)
+                                for t in tags:
+                                    if t not in seen[dedup_key]["tags"]:
+                                        seen[dedup_key]["tags"].append(t)
+
+                        except Exception:
+                            continue
+
+            except Exception as e:
+                log.warning(f"Failed to read WhatsApp IndexedDB for {profile.browser}/{profile.name}: {e}")
+            finally:
+                shutil.rmtree(tmp_db.parent, ignore_errors=True)
+                if tmp_blob:
+                    shutil.rmtree(tmp_blob.parent, ignore_errors=True)
+
+    # Upsert deduplicated contacts
+    for (name, _phone), entry in seen.items():
+        mem.upsert(f"contact:{name}", entry["value"], entry["tags"], source="whatsapp")
+
+    # Clean up old JID-format entries (@c.us, @s.whatsapp.net) that now have normalized phone values
+    old_jid_rows = mem.conn.execute("""
+        SELECT id, key, value FROM memories
+        WHERE source = 'whatsapp'
+          AND (value LIKE '%@c.us' OR value LIKE '%@s.whatsapp.net')
+          AND superseded_by IS NULL
+    """).fetchall()
+
+    cleaned = 0
+    for old_id, old_key, old_value in old_jid_rows:
+        # Check if a normalized version exists for the same contact name
+        normalized = mem.conn.execute("""
+            SELECT id FROM memories
+            WHERE key = ? AND source = 'whatsapp'
+              AND value NOT LIKE '%@c.us' AND value NOT LIKE '%@s.whatsapp.net'
+              AND superseded_by IS NULL
+            LIMIT 1
+        """, (old_key,)).fetchone()
+        if normalized:
+            mem.conn.execute(
+                "UPDATE memories SET superseded_by = ? WHERE id = ?",
+                (normalized[0], old_id),
+            )
+            cleaned += 1
+        else:
+            # No normalized version — delete the junk entry entirely
+            mem.conn.execute("DELETE FROM memories WHERE id = ?", (old_id,))
+            cleaned += 1
+
+    if cleaned:
+        mem.conn.commit()
+        log.info(f"  Cleaned {cleaned} old JID-format WhatsApp entries")
+
+    # Also clean up junk names that slipped through previous extractions
+    junk = mem.conn.execute("""
+        DELETE FROM memories
+        WHERE source = 'whatsapp' AND superseded_by IS NULL
+          AND (value = '<Undefined>' OR key = 'contact:.' OR key = 'contact:<Undefined>')
+    """).rowcount
+    if junk:
+        mem.conn.commit()
+        log.info(f"  Deleted {junk} junk WhatsApp entries")
+
+    log.info(f"  IndexedDB: {len(seen)} WhatsApp contacts (deduplicated)")

package/ai_browser_profile/ingestors/localstorage.py

@@ -0,0 +1,66 @@
+"""Ingest LinkedIn connections from Chromium Local Storage (LevelDB)."""
+
+import json
+import shutil
+import tempfile
+import logging
+from pathlib import Path
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile
+
+log = logging.getLogger(__name__)
+
+
+def ingest_localstorage(mem: MemoryDB, profiles: list[BrowserProfile]):
+    """Extract LinkedIn connections from Chromium Local Storage."""
+    from ccl_chromium_reader import ccl_chromium_localstorage
+
+    total = 0
+    for profile in profiles:
+        if profile.browser in ("safari", "firefox"):
+            continue
+
+        ls_dir = profile.path / "Local Storage" / "leveldb"
+        if not ls_dir.exists():
+            continue
+
+        tmp = Path(tempfile.mkdtemp(prefix="ai_browser_profile_ls_"))
+        tmp_ls = tmp / "leveldb"
+        try:
+            shutil.copytree(ls_dir, tmp_ls)
+        except Exception as e:
+            log.warning(f"Failed to copy Local Storage for {profile.browser}/{profile.name}: {e}")
+            shutil.rmtree(tmp, ignore_errors=True)
+            continue
+
+        try:
+            ldb = ccl_chromium_localstorage.LocalStoreDb(tmp_ls)
+            for record in ldb.iter_all_records():
+                try:
+                    origin = record.storage_key or ""
+                    key = record.script_key or ""
+
+                    # LinkedIn connections
+                    if "linkedin" in origin and key == "linkedin_assistant_profiles":
+                        value = record.value or ""
+                        data = json.loads(value)
+                        profiles_data = data.get("profiles", {})
+                        for url, p in profiles_data.items():
+                            name = p.get("name", "")
+                            title = p.get("title", "")
+                            if not name:
+                                continue
+                            value_str = title if title else url
+                            mem.upsert(f"linkedin:{name}", value_str,
+                                       ["contact", "work", "social"], source="linkedin")
+                            total += 1
+                except Exception:
+                    continue
+
+        except Exception as e:
+            log.warning(f"Failed to read Local Storage for {profile.browser}/{profile.name}: {e}")
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+    log.info(f"  Local Storage: {total} LinkedIn connections")

package/ai_browser_profile/ingestors/logins.py

@@ -0,0 +1,46 @@
+"""Ingest account/email memories from Chromium Login Data."""
+
+import shutil
+import sqlite3
+import logging
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile, copy_db, domain
+
+log = logging.getLogger(__name__)
+
+
+def ingest_logins(mem: MemoryDB, profiles: list[BrowserProfile]):
+    """Extract account and email memories from Chromium Login Data files."""
+    total = 0
+    for profile in profiles:
+        if profile.browser in ("safari", "firefox"):
+            continue  # No Login Data SQLite for these
+
+        tmp = copy_db(profile.path / "Login Data")
+        if not tmp:
+            continue
+        try:
+            conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+            conn.row_factory = sqlite3.Row
+            for row in conn.execute(
+                "SELECT origin_url, username_value, times_used FROM logins "
+                "WHERE username_value != '' ORDER BY times_used DESC LIMIT 200"
+            ):
+                d = domain(row["origin_url"])
+                username = row["username_value"]
+                use_count = row["times_used"] or 0
+                mem.upsert(f"account:{d}", username,
+                           ["account"], source=f"login:{d}")
+
+                if "@" in username:
+                    mem.upsert("email", username, ["identity", "contact_info", "communication"],
+                               source=f"login:{d}")
+                total += 1
+            conn.close()
+        except Exception as e:
+            log.warning(f"Failed to read Login Data for {profile.browser}/{profile.name}: {e}")
+        finally:
+            shutil.rmtree(tmp.parent, ignore_errors=True)
+
+    log.info(f"  Logins: {total} account entries")