ai-browser-profile 1.0.5 → 1.0.6

package/ai_browser_profile/cookies.py

@@ -0,0 +1,330 @@
+"""Read cookies from a Chromium browser profile and inject into another.
+
+Sibling to the ingestors in ai_browser_profile.ingestors. Lives in the
+package but is NOT wired into extract_memories() — cookies are auth
+secrets and must never land in memories.db.
+
+Public API:
+    read_cookies(profile, domains=None)   -> list[Cookie]
+    inject_via_cdp(cookies, cdp_url, ...) -> int
+
+CLI:
+    python -m ai_browser_profile.cookies copy \\
+        --from chrome:Default \\
+        --to cdp://127.0.0.1:9555 \\
+        --domains github.com,linear.app
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import logging
+import shutil
+import sqlite3
+import subprocess
+import sys
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Optional
+
+from ai_browser_profile.ingestors.browser_detect import (
+    BrowserProfile,
+    copy_db,
+    detect_browsers,
+)
+
+log = logging.getLogger(__name__)
+
+KEYCHAIN_SERVICE = {
+    "chrome": "Chrome Safe Storage",
+    "arc": "Arc Safe Storage",
+    "brave": "Brave Safe Storage",
+    "edge": "Microsoft Edge Safe Storage",
+    "chromium": "Chromium Safe Storage",
+}
+
+PBKDF2_SALT = b"saltysalt"
+PBKDF2_ITERATIONS = 1003
+AES_KEY_LENGTH = 16
+AES_IV = b" " * 16
+
+SAMESITE_MAP = {-1: "Unspecified", 0: "None", 1: "Lax", 2: "Strict"}
+
+
+@dataclass
+class Cookie:
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    secure: bool
+    http_only: bool
+    same_site: str
+
+
+def _keychain_password(browser: str) -> bytes:
+    service = KEYCHAIN_SERVICE.get(browser)
+    if not service:
+        raise ValueError(f"No keychain service mapped for browser {browser!r}")
+    res = subprocess.run(
+        ["security", "find-generic-password", "-w", "-s", service],
+        capture_output=True, text=True, check=False,
+    )
+    if res.returncode != 0:
+        raise RuntimeError(
+            f"Could not read {service!r} from Keychain: {res.stderr.strip() or 'access denied'}"
+        )
+    return res.stdout.strip().encode()
+
+
+def _derive_key(password: bytes) -> bytes:
+    return hashlib.pbkdf2_hmac(
+        "sha1", password, PBKDF2_SALT, PBKDF2_ITERATIONS, AES_KEY_LENGTH
+    )
+
+
+def _decrypt(encrypted: bytes, key: bytes, host_key: str) -> Optional[str]:
+    """Decrypt a Chromium cookie value. Returns None on failure."""
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+    if not encrypted:
+        return None
+    prefix = encrypted[:3]
+    if prefix in (b"v10", b"v11"):
+        payload = encrypted[3:]
+    else:
+        payload = encrypted
+    if len(payload) % 16 != 0:
+        return None
+    cipher = Cipher(algorithms.AES(key), modes.CBC(AES_IV))
+    dec = cipher.decryptor()
+    plain = dec.update(payload) + dec.finalize()
+    if not plain:
+        return None
+    pad = plain[-1]
+    if 1 <= pad <= 16 and plain.endswith(bytes([pad]) * pad):
+        plain = plain[:-pad]
+    # Chrome 80+ prepends SHA256(host_key) (32 bytes) to bind cookie to its host.
+    expected = hashlib.sha256(host_key.encode()).digest()
+    if plain.startswith(expected):
+        plain = plain[32:]
+    try:
+        return plain.decode("utf-8")
+    except UnicodeDecodeError:
+        return plain.decode("utf-8", errors="replace")
+
+
+def read_cookies(
+    profile: BrowserProfile,
+    domains: Optional[Iterable[str]] = None,
+) -> list[Cookie]:
+    """Read and decrypt cookies from a Chromium browser profile.
+
+    Args:
+        profile: A Chromium profile from detect_browsers().
+        domains: Optional iterable of substrings; a cookie is kept if its
+                 host_key contains any of them. None means all cookies.
+    """
+    if profile.browser in ("safari", "firefox"):
+        raise NotImplementedError(f"Cookie read not supported for {profile.browser}")
+
+    cookies_path = profile.path / "Cookies"
+    if not cookies_path.exists():
+        raise FileNotFoundError(f"No Cookies file at {cookies_path}")
+
+    tmp = copy_db(cookies_path)
+    if tmp is None:
+        raise RuntimeError(
+            f"Could not copy {cookies_path}. Grant Full Disk Access to your terminal and retry."
+        )
+
+    domain_filters = list(domains) if domains else None
+    key = _derive_key(_keychain_password(profile.browser))
+    cookies: list[Cookie] = []
+    skipped = 0
+    def _txt(b) -> str:
+        if b is None:
+            return ""
+        if isinstance(b, bytes):
+            return b.decode("utf-8", errors="replace")
+        return str(b)
+
+    try:
+        conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+        # Arc and some Chrome forks declare encrypted_value as TEXT, not BLOB,
+        # which makes sqlite3 try to UTF-8-decode the AES ciphertext and crash
+        # mid-iteration. Force everything to bytes and decode TEXT columns
+        # ourselves.
+        conn.text_factory = bytes
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            "SELECT host_key, name, value, encrypted_value, path, expires_utc, "
+            "is_secure, is_httponly, samesite FROM cookies"
+        )
+        for row in rows:
+            host = _txt(row["host_key"])
+            if domain_filters and not any(d in host for d in domain_filters):
+                continue
+            value = _txt(row["value"])
+            if not value and row["encrypted_value"]:
+                value = _decrypt(row["encrypted_value"], key, host) or ""
+                if not value:
+                    skipped += 1
+                    continue
+            expires = 0.0
+            if row["expires_utc"]:
+                # Chromium epoch is 1601-01-01 in microseconds.
+                expires = (row["expires_utc"] / 1_000_000) - 11644473600
+            cookies.append(Cookie(
+                name=_txt(row["name"]),
+                value=value,
+                domain=host,
+                path=_txt(row["path"]) or "/",
+                expires=expires,
+                secure=bool(row["is_secure"]),
+                http_only=bool(row["is_httponly"]),
+                same_site=SAMESITE_MAP.get(row["samesite"], "Unspecified"),
+            ))
+        conn.close()
+    finally:
+        shutil.rmtree(tmp.parent, ignore_errors=True)
+
+    log.info(
+        "Read %d cookies from %s/%s (skipped %d undecryptable)",
+        len(cookies), profile.browser, profile.name, skipped,
+    )
+    return cookies
+
+
+def _ws_from_cdp_url(cdp_url: str) -> str:
+    if cdp_url.startswith("ws://") or cdp_url.startswith("wss://"):
+        return cdp_url
+    if cdp_url.startswith("cdp://"):
+        cdp_url = "http://" + cdp_url[len("cdp://"):]
+    base = cdp_url.rstrip("/")
+    with urllib.request.urlopen(f"{base}/json/version", timeout=5) as r:
+        return json.loads(r.read())["webSocketDebuggerUrl"]
+
+
+def inject_via_cdp(
+    cookies: Iterable[Cookie],
+    cdp_url: str = "http://127.0.0.1:9222",
+) -> int:
+    """Inject cookies into a running Chrome via CDP Storage.setCookies.
+
+    Args:
+        cookies: iterable of Cookie objects.
+        cdp_url: base http(s) URL of the Chrome DevTools endpoint, or a
+                 cdp://host:port shorthand, or a raw ws:// URL.
+
+    Returns: number of cookies submitted (the browser accepts them as a batch).
+    """
+    from websocket import create_connection
+
+    ws_url = _ws_from_cdp_url(cdp_url)
+    # Chrome 111+ enforces CDP origin checking and rejects any Origin header
+    # unless the target was launched with --remote-allow-origins. Suppressing
+    # the header bypasses the check; localhost CDP is already privileged.
+    ws = create_connection(ws_url, timeout=10, suppress_origin=True)
+    try:
+        batch = []
+        for c in cookies:
+            param = {
+                "name": c.name,
+                "value": c.value,
+                "domain": c.domain,
+                "path": c.path or "/",
+                "secure": c.secure,
+                "httpOnly": c.http_only,
+            }
+            if c.same_site in ("Strict", "Lax", "None"):
+                param["sameSite"] = c.same_site
+            if c.expires > 0:
+                param["expires"] = c.expires
+            batch.append(param)
+        if not batch:
+            return 0
+        ws.send(json.dumps({
+            "id": 1,
+            "method": "Storage.setCookies",
+            "params": {"cookies": batch},
+        }))
+        resp = json.loads(ws.recv())
+        if "error" in resp:
+            log.warning("Storage.setCookies failed: %s", resp["error"])
+            return 0
+    finally:
+        ws.close()
+    log.info("Injected %d cookies via CDP", len(batch))
+    return len(batch)
+
+
+# --- helpers used by CLI and external callers ---
+
+def find_profile(spec: str) -> BrowserProfile:
+    """Resolve a 'browser:profile-name' spec (e.g. 'chrome:Default') to a BrowserProfile."""
+    if ":" in spec:
+        browser, name = spec.split(":", 1)
+    else:
+        browser, name = spec, "Default"
+    matches = [p for p in detect_browsers({browser}) if p.name == name]
+    if not matches:
+        available = [(p.browser, p.name) for p in detect_browsers({browser})]
+        raise SystemExit(
+            f"No profile {spec!r}. Available {browser} profiles: {available}"
+        )
+    return matches[0]
+
+
+def _cli(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m ai_browser_profile.cookies")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    cp = sub.add_parser("copy", help="copy cookies from a local profile into a running browser via CDP")
+    cp.add_argument("--from", dest="src", required=True,
+                    help="source profile, e.g. chrome:Default or arc:'Profile 1'")
+    cp.add_argument("--to", dest="dst", required=True,
+                    help="target CDP endpoint, e.g. cdp://127.0.0.1:9555 or http://127.0.0.1:9555")
+    cp.add_argument("--domains", default=None,
+                    help="comma-separated list of host_key substrings to include")
+    cp.add_argument("-v", "--verbose", action="store_true")
+
+    ls = sub.add_parser("list", help="list cookies in a local profile (counts only — no values printed)")
+    ls.add_argument("--from", dest="src", required=True)
+    ls.add_argument("--domains", default=None)
+
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if getattr(args, "verbose", False) else logging.INFO,
+        format="%(levelname)s %(message)s",
+    )
+
+    profile = find_profile(args.src)
+    domain_filters = [d.strip() for d in args.domains.split(",")] if args.domains else None
+
+    cookies = read_cookies(profile, domains=domain_filters)
+
+    if args.cmd == "list":
+        by_host: dict[str, int] = {}
+        for c in cookies:
+            by_host[c.domain] = by_host.get(c.domain, 0) + 1
+        for host, n in sorted(by_host.items(), key=lambda kv: -kv[1]):
+            print(f"  {n:4}  {host}")
+        print(f"Total: {len(cookies)} cookies across {len(by_host)} hosts")
+        return 0
+
+    if args.cmd == "copy":
+        n = inject_via_cdp(cookies, args.dst)
+        print(f"Injected {n}/{len(cookies)} cookies into {args.dst}")
+        return 0 if n > 0 else 2
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(_cli())

package/ai_browser_profile/extract.py

@@ -40,6 +40,7 @@ def extract_memories(memories_db_path: str = "memories.db",
     """
     total_start = time.monotonic()
     mem = MemoryDB(memories_db_path, defer_embeddings=True)
+    from ai_browser_profile.ingestors.browser_detect import permission_denied_paths
     profiles = detect_browsers(allowed=browsers)
     log.info(f"Extracting memories from {len(profiles)} profiles...")
 
@@ -80,6 +81,17 @@ def extract_memories(memories_db_path: str = "memories.db",
     run_cleanup(db_path=memories_db_path)
     mem = MemoryDB(memories_db_path, defer_embeddings=True)
     interim_profile = mem.profile_text()
+
+    # Emit structured browser summary so callers can show transparency
+    detected_browsers = sorted(set(p.browser for p in profiles))
+    denied_browsers = sorted(set(
+        p.browser for p in profiles
+        if any(str(p.path) in str(denied) for denied in permission_denied_paths)
+    ))
+    print(f"BROWSERS_SCANNED: {','.join(detected_browsers)}", flush=True)
+    if denied_browsers:
+        print(f"BROWSERS_PERMISSION_DENIED: {','.join(denied_browsers)}", flush=True)
+
     log.info(f"Interim profile ready (WhatsApp + embeddings still running):\n{interim_profile}")
 
     # 7. WhatsApp — contacts from IndexedDB (slow, runs last)

package/ai_browser_profile/ingestors/browser_detect.py

@@ -13,6 +13,9 @@ log = logging.getLogger(__name__)
 
 APP_SUPPORT = Path.home() / "Library" / "Application Support"
 
+# Populated by copy_db() when a file can't be read due to TCC permissions
+permission_denied_paths: list[Path] = []
+
 
 @dataclass
 class BrowserProfile:
@@ -89,6 +92,7 @@ def copy_db(src: Path) -> Optional[Path]:
         return dst
     except PermissionError:
         log.warning(f"Permission denied reading {src} — grant Full Disk Access or skip")
+        permission_denied_paths.append(src)
         return None
 
 

package/ai_browser_profile/localstorage.py

@@ -0,0 +1,266 @@
+"""Read localStorage from a Chromium browser profile and inject into another.
+
+Sibling to cookies.py. Like cookies.py, this is NOT wired into
+extract_memories() — localStorage values can include auth tokens and
+must not land in memories.db.
+
+Public API:
+    read_localstorage(profile, origins=None)            -> dict[origin, dict[key, value]]
+    inject_localstorage_via_cdp(data, cdp_url, ...)     -> int
+
+CLI:
+    python -m ai_browser_profile.localstorage copy \\
+        --from chrome:Profile\\ 1 \\
+        --to cdp://127.0.0.1:9555 \\
+        --origins chatgpt.com,notion.so
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import shutil
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Iterable, Optional
+
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile
+from ai_browser_profile.cookies import _ws_from_cdp_url, find_profile
+
+log = logging.getLogger(__name__)
+
+
+def read_localstorage(
+    profile: BrowserProfile,
+    origins: Optional[Iterable[str]] = None,
+) -> dict[str, dict[str, str]]:
+    """Read localStorage from a Chromium profile's LevelDB.
+
+    Args:
+        profile: Chromium profile from detect_browsers().
+        origins: Optional iterable of substrings; an origin is kept if any
+                 substring matches its storage_key (e.g. 'chatgpt.com'
+                 matches 'https://chatgpt.com'). None = all origins.
+
+    Returns: dict mapping origin (e.g. 'https://chatgpt.com') to dict of key/value.
+    """
+    if profile.browser in ("safari", "firefox"):
+        raise NotImplementedError(f"localStorage read not supported for {profile.browser}")
+
+    ls_dir = profile.path / "Local Storage" / "leveldb"
+    if not ls_dir.exists():
+        raise FileNotFoundError(f"No Local Storage/leveldb at {ls_dir}")
+
+    tmp = Path(tempfile.mkdtemp(prefix="ai_browser_profile_ls_"))
+    tmp_ls = tmp / "leveldb"
+    try:
+        shutil.copytree(ls_dir, tmp_ls)
+    except Exception as e:
+        shutil.rmtree(tmp, ignore_errors=True)
+        raise RuntimeError(f"Could not copy {ls_dir}: {e}") from e
+
+    origin_filters = list(origins) if origins else None
+    out: dict[str, dict[str, str]] = {}
+    skipped = 0
+
+    try:
+        from ccl_chromium_reader import ccl_chromium_localstorage
+
+        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 ""
+                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):
+                    continue
+                if isinstance(value, bytes):
+                    try:
+                        value = value.decode("utf-8")
+                    except UnicodeDecodeError:
+                        skipped += 1
+                        continue
+                elif not isinstance(value, str):
+                    value = str(value)
+                out.setdefault(origin, {})[key] = value
+            except Exception:
+                skipped += 1
+                continue
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    total = sum(len(v) for v in out.values())
+    log.info(
+        "Read %d localStorage items across %d origins from %s/%s (skipped %d)",
+        total, len(out), profile.browser, profile.name, skipped,
+    )
+    return out
+
+
+def _cdp_send(ws, msg_id: int, method: str,
+              params: Optional[dict] = None,
+              session_id: Optional[str] = None) -> dict:
+    """Send a CDP message and drain events until the matching reply arrives."""
+    msg: dict = {"id": msg_id, "method": method}
+    if params:
+        msg["params"] = params
+    if session_id:
+        msg["sessionId"] = session_id
+    ws.send(json.dumps(msg))
+    deadline = time.time() + 20
+    while time.time() < deadline:
+        resp = json.loads(ws.recv())
+        if resp.get("id") == msg_id:
+            return resp
+    raise TimeoutError(f"CDP {method} timed out")
+
+
+def inject_localstorage_via_cdp(
+    data: dict[str, dict[str, str]],
+    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.
+
+    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.
+
+    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).
+    """
+    from websocket import create_connection
+
+    ws_url = _ws_from_cdp_url(cdp_url)
+    ws = create_connection(ws_url, timeout=15, suppress_origin=True)
+    msg_id = 0
+    total_set = 0
+
+    try:
+        for origin, items in data.items():
+            if not items:
+                continue
+            if not origin.startswith("http"):
+                log.warning("Skipping non-http origin %r", origin)
+                continue
+            # Skip partitioned-storage origins like
+            # 'https://www.youtube.com/^0https://openai.com'. The '^' marker
+            # is Chromium's third-party storage partitioning; we can't navigate
+            # to that as a top-level URL.
+            if "^" in origin:
+                log.info("Skipping partitioned origin %r", origin)
+                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)
+
+                # 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
+    finally:
+        ws.close()
+
+    log.info("Injected %d localStorage items total", total_set)
+    return total_set
+
+
+def _cli(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m ai_browser_profile.localstorage")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    cp = sub.add_parser("copy", help="copy localStorage from a local profile into a running browser via CDP")
+    cp.add_argument("--from", dest="src", required=True,
+                    help="source profile, e.g. chrome:Default or 'chrome:Profile 1'")
+    cp.add_argument("--to", dest="dst", required=True,
+                    help="target CDP endpoint, e.g. cdp://127.0.0.1:9555")
+    cp.add_argument("--origins", default=None,
+                    help="comma-separated host substrings (e.g. 'chatgpt.com,notion.so')")
+    cp.add_argument("--load-wait", type=float, default=4.0,
+                    help="seconds to wait after opening each tab before injecting (default 4)")
+    cp.add_argument("-v", "--verbose", action="store_true")
+
+    ls = sub.add_parser("list", help="list localStorage origins (counts only — no values printed)")
+    ls.add_argument("--from", dest="src", required=True)
+    ls.add_argument("--origins", default=None)
+
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if getattr(args, "verbose", False) else logging.INFO,
+        format="%(levelname)s %(message)s",
+    )
+
+    profile = find_profile(args.src)
+    origin_filters = [o.strip() for o in args.origins.split(",")] if args.origins else None
+
+    data = read_localstorage(profile, origins=origin_filters)
+
+    if args.cmd == "list":
+        for origin, items in sorted(data.items(), key=lambda kv: -len(kv[1])):
+            print(f"  {len(items):4}  {origin}")
+        total = sum(len(v) for v in data.values())
+        print(f"Total: {total} items across {len(data)} origins")
+        return 0
+
+    if args.cmd == "copy":
+        n = inject_localstorage_via_cdp(data, args.dst, load_wait_sec=args.load_wait)
+        total = sum(len(v) for v in data.values())
+        print(f"Injected {n}/{total} localStorage items into {args.dst}")
+        return 0 if n > 0 else 2
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(_cli())

package/bin/cli.js

@@ -25,11 +25,15 @@ const COPY_TARGETS = [
 // Never overwrite these during update
 const NEVER_OVERWRITE = new Set(['memories.db', '.venv', 'scripts', 'config.json']);
 
-// Core Python deps (tier 1) — enough for tag search, SQL, extraction
-// ccl_chromium_reader is only on GitHub, not PyPI
+// Core Python deps (tier 1) — enough for tag search, SQL, extraction,
+// plus cookies + localStorage sync (cryptography for AES-CBC decrypt of
+// Chromium cookie blobs, websocket-client for CDP injection).
+// ccl_chromium_reader is only on GitHub, not PyPI.
 const CORE_DEPS = [
   'git+https://github.com/cclgroupltd/ccl_chromium_reader.git',
   'numpy',
+  'cryptography',
+  'websocket-client',
 ];
 
 // Embedding deps (tier 2) — optional, for semantic search

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "ai-browser-profile",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "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"
   },
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
+  },
   "files": [
     "bin/",
     "ai_browser_profile/**/*.py",
@@ -36,5 +42,26 @@
   "homepage": "https://github.com/m13v/ai-browser-profile",
   "engines": {
     "node": ">=16"
+  },
+  "devDependencies": {
+    "@assistant-ui/react": "^0.12.25",
+    "@google/generative-ai": "^0.24.1",
+    "@m13v/seo-components": "^0.40.0",
+    "@remotion/player": "^4.0.446",
+    "@seo/components": "npm:@m13v/seo-components@^0.40.0",
+    "@supabase/supabase-js": "^2.103.3",
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "framer-motion": "^12.38.0",
+    "lottie-react": "^2.4.1",
+    "next": "16.2.2",
+    "posthog-js": "^1.369.2",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "remotion": "^4.0.446",
+    "tailwindcss": "^4",
+    "typescript": "^5"
   }
 }

package/review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memory-review
-description: "Review and clean unreviewed memories in the database. Removes junk, merges duplicates, fixes miskeyed data, and marks good entries as reviewed. Run periodically after extraction."
+description: "Use when the user says 'review memories', 'clean up the memory database', 'process unreviewed memories', 'memory cleanup', 'merge duplicate memories', or wants periodic LLM-powered post-ingestion review. Removes junk, merges duplicates, fixes miskeyed data, marks good entries as reviewed."
 ---
 
 # Memory Review

package/skill/SKILL.md

@@ -1,180 +1,47 @@
 ---
 name: ai-browser-profile
-description: "Query the user's AI browser profile: identity, accounts, tools, contacts, addresses, payments extracted from browser data. Use when you need context about the user to help with any task: form filling, emailing, booking, payments, or any task where knowing the user's info helps."
+description: "Query the user's browser-extracted profile: identity, accounts, tools, contacts, addresses, payments. Use when the user asks about their own info or you need personal context."
 ---
 
 # AI Browser Profile
 
-A self-ranking database of everything learned about the user from browser data. Memories are ranked by how often they're accessed vs how often they appear in search results — frequently useful memories rise, noise sinks.
+Locally-extracted profile of the user built from their browser data (autofill, saved logins, history, bookmarks, WhatsApp, LinkedIn). Stored in `~/ai-browser-profile/memories.db`. Nothing leaves the machine.
 
-## Quick Reference
+## When to use `query_browser_profile`
 
-| Item | Value |
-|------|-------|
-| Database | `~/ai-browser-profile/memories.db` |
-| Module | `~/ai-browser-profile/ai_browser_profile/` |
-| Python | `~/ai-browser-profile/.venv/bin/python` |
-| Rebuild | `~/ai-browser-profile/.venv/bin/python ~/ai-browser-profile/extract.py` |
+Use this tool proactively whenever the user asks about themselves or you need personal context:
 
-## How to Use
+| User asks... | Query |
+|---|---|
+| "What's my email?" | query: "email address", tags: ["contact_info"] |
+| "What accounts do I have?" | query: "saved accounts", tags: ["account"] |
+| "What tools do I use?" | query: "tools and services", tags: ["tool"] |
+| "Find contact X" | query: "X", tags: ["contact"] |
+| "What's my address?" | query: "home address", tags: ["address"] |
+| "What card do I use?" | query: "payment card", tags: ["payment"] |
+| "Who am I?" / profile | query: "profile", tags: ["identity"] |
 
-### User profile (start here)
+## Tool parameters
 
-Get a compact overview of the user — name, emails, addresses, accounts, tools, contacts. This is deterministic (no LLM) and computed from the database. Use it as baseline context before doing any task.
-
-```python
-import sys, os
-sys.path.insert(0, os.path.expanduser("~/ai-browser-profile"))
-from ai_browser_profile import MemoryDB
-
-mem = MemoryDB(os.path.expanduser("~/ai-browser-profile/memories.db"))
-print(mem.profile_text())  # markdown formatted, ~1.5KB
-mem.close()
-```
-
-The profile shows: name, all known emails, phone numbers, handles, addresses, payment info, companies, top tools/services, accounts grouped by email, Notion projects, and contact count. Values are ranked by frequency across browser profiles — higher frequency = more likely to be the user's own data.
-
-### Search by tags
-
-```python
-import sys, os
-sys.path.insert(0, os.path.expanduser("~/ai-browser-profile"))
-from ai_browser_profile import MemoryDB
-
-mem = MemoryDB(os.path.expanduser("~/ai-browser-profile/memories.db"))
-
-# Search returns results ranked by hit_rate (accessed/appeared), then counts
-# accessed_count and appeared_count are auto-incremented on every search call
-results = mem.search(["identity", "contact_info"], limit=10)
-for r in results:
-    print(f'{r["key"]}: {r["value"]}')
-
-mem.close()
 ```
-
-### Semantic search (natural language)
-
-```python
-# Find memories by meaning, not just keywords
-results = mem.semantic_search("what products does the user build")
-for r in results[:5]:
-    print(f'{r["key"]}: {r["value"][:80]} (sim={r["similarity"]:.3f})')
-
-# Falls back to text_search() if embeddings not installed
-# Install with: npx ai-browser-profile install-embeddings
-```
-
-### Quick SQL queries
-
-```bash
-sqlite3 ~/ai-browser-profile/memories.db
-```
-
-```sql
--- All identity info
-SELECT m.key, m.value FROM memories m
-JOIN memory_tags t ON m.id = t.memory_id WHERE t.tag = 'identity'
-AND m.superseded_by IS NULL;
-
--- All contact info (emails, phones)
-SELECT m.key, m.value, m.source FROM memories m
-JOIN memory_tags t ON m.id = t.memory_id WHERE t.tag = 'contact_info'
-AND m.superseded_by IS NULL;
-
--- All contacts
-SELECT m.key, m.value FROM memories m
-JOIN memory_tags t ON m.id = t.memory_id WHERE t.tag = 'contact'
-AND m.superseded_by IS NULL
-ORDER BY m.accessed_count DESC;
-
--- Most accessed memories (the ones that proved useful)
-SELECT key, value, accessed_count, appeared_count,
-       CAST(accessed_count AS REAL) / MAX(appeared_count, 1) AS hit_rate
-FROM memories WHERE accessed_count > 0
-ORDER BY hit_rate DESC;
-
--- Search by key pattern
-SELECT key, value FROM memories WHERE key LIKE 'account:%'
-AND superseded_by IS NULL;
+query_browser_profile(
+  query: string,           // natural language query
+  tags?: string[]          // optional: identity, contact_info, account, tool,
+                           //           address, payment, contact, work, knowledge
+)
 ```
 
-## Canonical Tags
-
-| Tag | What it covers | Example keys |
-|-----|---------------|-------------|
-| `identity` | Name, DOB, gender, job title, language | `first_name`, `last_name`, `full_name`, `date_of_birth` |
-| `contact_info` | Email addresses, phone numbers | `email`, `phone` |
-| `address` | Physical addresses | `street_address`, `city`, `state`, `zip`, `country` |
-| `payment` | Card holder names, expiry | `card_holder_name`, `card_expiry`, `card_nickname` |
-| `account` | Service accounts, login credentials | `account:{domain}` |
-| `tool` | Tools/services used (from history) | `tool:GitHub`, `tool:Slack`, `tool:Stripe` |
-| `contact` | People the user knows | `contact:{Name}`, `linkedin:{Name}` |
-| `work` | Work-related (company, LinkedIn) | `company`, `linkedin:*` |
-| `knowledge` | Interests, skills, projects, products | `product:*`, `project:*`, `interest:*` |
-| `communication` | Messaging platforms | `tool:Slack`, `tool:WhatsApp` |
-| `social` | Social platforms | `tool:LinkedIn`, `tool:X/Twitter` |
-| `finance` | Financial tools | `tool:Stripe`, `tool:QuickBooks` |
-
-## Ranking System
-
-Every `search()`, `semantic_search()`, and `text_search()` call automatically increments both `appeared_count` and `accessed_count` for all returned results. No manual `mark_accessed()` calls needed.
-
-**hit_rate** = `accessed_count / appeared_count`
-
-Memories that are frequently returned by searches rise in ranking. The system is fully automatic — no manual curation or agent instrumentation needed.
+Returns ranked results from the local database. Results are self-ranking — frequently accessed ones surface automatically.
 
-## Semantic Dedup
+## Full profile
 
-On `upsert()`, near-duplicate memories (cosine similarity >= 0.92 with same key prefix) are automatically superseded. This prevents storing "Screen recording tool for compliance" and "Screen recording tool launched on Product Hunt for compliance use cases" as separate entries.
-
-## Task-Specific Tag Queries
-
-| Task | Tags to search |
-|------|---------------|
-| Fill out a form | `["identity", "contact_info", "address"]` |
-| Send an email | `["contact_info", "communication"]` + search contact by name |
-| Book a flight/hotel | `["identity", "address", "payment"]` |
-| Log into a service | `["account"]` |
-| Invoice a client | `["identity", "work", "address", "payment"]` |
-| Find a contact | `["contact"]` + filter by key pattern |
-| Dev/deploy task | `["account", "tool"]` |
-| Social media post | `["account", "social"]` |
-| Research question | `mem.semantic_search("your question here")` |
-
-## Rebuilding Memories
-
-To refresh from latest browser data:
-
-```bash
-cd ~/ai-browser-profile
-source .venv/bin/activate
-python extract.py                                    # full scan
-python extract.py --browsers arc chrome              # specific browsers
-python extract.py --no-indexeddb --no-localstorage   # fast, skip LevelDB
+To get the complete user profile in one call:
 ```
-
-### Backfill embeddings (after install-embeddings)
-
-```python
-import sys, os
-sys.path.insert(0, os.path.expanduser("~/ai-browser-profile"))
-from ai_browser_profile import MemoryDB
-mem = MemoryDB(os.path.expanduser("~/ai-browser-profile/memories.db"))
-n = mem.backfill_embeddings()
-print(f"Embedded {n} memories")
-mem.close()
+query_browser_profile(query: "full profile")
 ```
 
-This reads browser files directly (History, Login Data, Web Data, IndexedDB, Local Storage). The memory database preserves `appeared_count` and `accessed_count` across rebuilds via UPSERT logic — rankings are never lost.
-
-## Dependencies
+Returns name, emails, phone, addresses, payment info, companies, top tools, accounts.
 
-**Core** (installed by `npx ai-browser-profile init`):
-- `ccl_chromium_reader` — IndexedDB + Local Storage LevelDB files
-- `numpy` — vector math for cosine similarity
+## Availability
 
-**Embeddings** (optional, installed by `npx ai-browser-profile install-embeddings`):
-- `onnxruntime` — ONNX model inference
-- `huggingface_hub` — model downloading
-- `tokenizers` — text tokenization
-- Model: nomic-embed-text-v1.5 (~131MB, downloads on first use)
+Requires browser data extraction during onboarding. If queries return no results, call `extract_browser_profile` to re-run the extraction — it uses the native Swift extractor built into the app (no external tools needed).