evolutiondb-browser-sync 0.1.0__py3-none-any.whl

browser_sync/__init__.py

@@ -0,0 +1,10 @@
+"""evolutiondb-browser-sync — read local browser history (Chrome,
+Edge, Firefox, Brave, Arc, Vivaldi) directly from each browser's
+on-disk SQLite store and pour the entries into EvolutionDB
+long-term memory.
+
+No OAuth, no extension install, no remote API. The browser's own
+data lives in a local file the user already owns, so the sync
+just opens it read-only and copies the rows out."""
+
+__version__ = "0.1.0"

browser_sync/__main__.py

@@ -0,0 +1,4 @@
+from .sync import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

browser_sync/extract.py

@@ -0,0 +1,212 @@
+"""
+Open a browser history SQLite store in read-only mode and yield
+normalised visit records. Two on-disk schemas exist in the wild —
+the Chromium family (Chrome, Edge, Brave, Arc, Vivaldi, Opera) and
+Mozilla Firefox. Each gets its own SELECT; the records they
+produce share a single shape so the sync loop downstream does not
+care which browser they came from.
+
+Locking
+-------
+A running browser holds an exclusive WAL lock on its History /
+places.sqlite file. We snapshot to a temp file with `shutil.copy`
+first; on Windows that step can race a busy browser and raise
+`PermissionError`, in which case we fall back to SQLite's URI
+`mode=ro&immutable=1` open which often succeeds on the original.
+"""
+from __future__ import annotations
+
+import hashlib
+import shutil
+import sqlite3
+import sys
+import tempfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Dict, Iterator, Optional
+
+from .scanner import CHROMIUM, FIREFOX, Profile
+
+
+_CHROME_EPOCH = datetime(1601, 1, 1, tzinfo=timezone.utc)
+_SKIP_PREFIXES = (
+    "chrome://", "chrome-extension://", "chrome-search://",
+    "chrome-untrusted://", "edge://", "extension://",
+    "moz-extension://", "about:", "view-source:",
+    "file://", "data:", "javascript:", "blob:",
+)
+
+
+# ---------------------------------------------------------------- #
+#  Snapshot + connect                                               #
+# ---------------------------------------------------------------- #
+def _snapshot(src: Path) -> Path:
+    tmp = Path(tempfile.mkstemp(suffix=".db",
+                                   prefix="evosql-bs-")[1])
+    try:
+        shutil.copy(src, tmp)
+        # WAL sidecars carry uncommitted history; copying them too
+        # avoids "no such table: visits" on freshly-opened browsers.
+        for sfx in ("-wal", "-shm"):
+            side = src.parent / (src.name + sfx)
+            if side.is_file():
+                try:
+                    shutil.copy(side, tmp.parent / (tmp.name + sfx))
+                except OSError:
+                    pass
+        return tmp
+    except PermissionError:
+        # Windows + browser exclusively locked. Cleanup, signal
+        # caller to fall back to URI immutable open of the original.
+        try:
+            tmp.unlink(missing_ok=True)
+        except Exception:
+            pass
+        raise
+
+
+def _connect(src: Path) -> sqlite3.Connection:
+    try:
+        snap = _snapshot(src)
+        return sqlite3.connect(snap)
+    except PermissionError:
+        # Last-resort: read the live file in immutable mode. Will
+        # surface uncommitted rows when -wal exists, but at least
+        # surfaces something on busy Windows hosts.
+        return sqlite3.connect(
+            f"file:{src}?mode=ro&immutable=1", uri=True)
+
+
+# ---------------------------------------------------------------- #
+#  Timestamp normalisation                                          #
+# ---------------------------------------------------------------- #
+def _chrome_us_to_iso(us: int) -> Optional[str]:
+    if not us or us < 0:
+        return None
+    try:
+        dt = _CHROME_EPOCH + timedelta(microseconds=int(us))
+        return dt.isoformat(timespec="seconds").replace("+00:00", "Z")
+    except (OverflowError, OSError):
+        return None
+
+
+def _firefox_us_to_iso(us: int) -> Optional[str]:
+    if not us or us < 0:
+        return None
+    try:
+        dt = datetime.fromtimestamp(int(us) / 1_000_000,
+                                       tz=timezone.utc)
+        return dt.isoformat(timespec="seconds").replace("+00:00", "Z")
+    except (OverflowError, OSError, ValueError):
+        return None
+
+
+# ---------------------------------------------------------------- #
+#  Filtering                                                        #
+# ---------------------------------------------------------------- #
+def _keep(url: str) -> bool:
+    if not url:
+        return False
+    lower = url.lower()
+    if lower.startswith(_SKIP_PREFIXES):
+        return False
+    return True
+
+
+# ---------------------------------------------------------------- #
+#  Record builder                                                   #
+# ---------------------------------------------------------------- #
+def _short_url(url: str, n: int = 80) -> str:
+    return url if len(url) <= n else url[: n - 1] + "…"
+
+
+def _build_record(profile: Profile, url: str, title: str,
+                    visit_count: int, last_iso: str) -> Dict:
+    title = (title or "").strip() or "(no title)"
+    fact = (f"Visited [{profile.browser}] \"{title}\" "
+              f"({_short_url(url)}) — last on {last_iso}, "
+              f"{visit_count} visit{'s' if visit_count != 1 else ''}")
+    url_hash = hashlib.sha1(url.encode("utf-8")).hexdigest()[:16]
+    return {
+        "fact":            fact,
+        "source":          "browser",
+        "kind":            "visit",
+        "browser":         profile.browser,
+        "browser_family":  profile.family,
+        "profile":         profile.profile_id,
+        "url":             url,
+        "title":           title,
+        "visit_count":     int(visit_count or 0),
+        "last_visited_at": last_iso,
+        "url_hash":        url_hash,
+        "tags":            ["browser", "history", profile.browser],
+    }
+
+
+# ---------------------------------------------------------------- #
+#  Per-family SELECT                                                #
+# ---------------------------------------------------------------- #
+def _iter_chromium(profile: Profile,
+                    since_iso: Optional[str]) -> Iterator[Dict]:
+    """Chromium schema: `urls(url, title, visit_count,
+    last_visit_time)`. `last_visit_time` is Chrome epoch
+    microseconds since 1601."""
+    conn = _connect(profile.history_path)
+    try:
+        try:
+            cur = conn.execute(
+                "SELECT url, title, visit_count, last_visit_time "
+                "FROM urls WHERE last_visit_time > 0")
+        except sqlite3.DatabaseError as exc:
+            print(f"[browser-sync] {profile.profile_id} "
+                  f"DB error: {exc}", file=sys.stderr, flush=True)
+            return
+        for url, title, visits, last in cur:
+            if not _keep(url):
+                continue
+            iso = _chrome_us_to_iso(last)
+            if iso is None:
+                continue
+            if since_iso and iso < since_iso:
+                continue
+            yield _build_record(profile, url, title, visits, iso)
+    finally:
+        conn.close()
+
+
+def _iter_firefox(profile: Profile,
+                    since_iso: Optional[str]) -> Iterator[Dict]:
+    """Firefox schema: `moz_places(url, title, visit_count,
+    last_visit_date)`. `last_visit_date` is Unix microseconds."""
+    conn = _connect(profile.history_path)
+    try:
+        try:
+            cur = conn.execute(
+                "SELECT url, title, visit_count, last_visit_date "
+                "FROM moz_places WHERE last_visit_date IS NOT NULL")
+        except sqlite3.DatabaseError as exc:
+            print(f"[browser-sync] {profile.profile_id} "
+                  f"DB error: {exc}", file=sys.stderr, flush=True)
+            return
+        for url, title, visits, last in cur:
+            if not _keep(url):
+                continue
+            iso = _firefox_us_to_iso(last)
+            if iso is None:
+                continue
+            if since_iso and iso < since_iso:
+                continue
+            yield _build_record(profile, url, title, visits, iso)
+    finally:
+        conn.close()
+
+
+def iter_visits(profile: Profile,
+                 since_iso: Optional[str] = None) -> Iterator[Dict]:
+    """Yield normalised visit records for a profile, optionally
+    filtered to only the rows whose latest visit is after
+    `since_iso` (a UTC ISO 8601 string)."""
+    if profile.family == CHROMIUM:
+        yield from _iter_chromium(profile, since_iso)
+    elif profile.family == FIREFOX:
+        yield from _iter_firefox(profile, since_iso)

browser_sync/scanner.py

@@ -0,0 +1,223 @@
+"""
+Enumerate every browser profile the current user owns across the
+three desktop OSes. Yields one (browser_family, browser_label,
+profile_id, history_path) tuple per discovered profile.
+
+Supports
+--------
+  Chromium family  Chrome, Edge, Brave, Arc, Vivaldi, Chromium
+  Mozilla family   Firefox (incl. Developer / Nightly / ESR)
+
+Cross-OS path handling
+----------------------
+  macOS    ~/Library/Application Support/<vendor>/...
+  Linux    ~/.config/<vendor>/... + snap + flatpak sandbox paths
+  Windows  %LOCALAPPDATA% or %APPDATA%\\<vendor>\\...
+
+Firefox is special: the profile directory has a random id; the
+active profile names live in profiles.ini next to the directory.
+We enumerate every *.default* directory plus whatever profiles.ini
+lists so users with multiple profiles all flow through.
+"""
+from __future__ import annotations
+
+import configparser
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, List
+
+
+CHROMIUM   = "chromium"
+FIREFOX    = "firefox"
+
+
+@dataclass(frozen=True)
+class Profile:
+    family:        str    # "chromium" | "firefox"
+    browser:       str    # "chrome" | "edge" | "brave" | "arc" | "vivaldi" | "firefox"
+    profile_id:    str    # "Default", "Profile 1", or firefox random id
+    history_path:  Path
+
+
+# ---------------------------------------------------------------- #
+#  Per-platform vendor roots                                        #
+# ---------------------------------------------------------------- #
+def _chromium_roots() -> List[tuple]:
+    """Return list of (browser_id, browser_label, user_data_root)
+    candidates for every Chromium-family browser known to the
+    current OS."""
+    home = Path.home()
+    p = sys.platform
+    out: List[tuple] = []
+
+    if p == "darwin":
+        base = home / "Library/Application Support"
+        out += [
+            ("chrome",     "Chrome",      base / "Google/Chrome"),
+            ("chrome",     "Chrome Beta", base / "Google/Chrome Beta"),
+            ("chrome",     "Chromium",    base / "Chromium"),
+            ("edge",       "Edge",        base / "Microsoft Edge"),
+            ("brave",      "Brave",       base / "BraveSoftware/Brave-Browser"),
+            ("arc",        "Arc",         base / "Arc/User Data"),
+            ("vivaldi",    "Vivaldi",     base / "Vivaldi"),
+            ("opera",      "Opera",       base / "com.operasoftware.Opera"),
+        ]
+    elif p.startswith("linux"):
+        cfg = home / ".config"
+        out += [
+            ("chrome",  "Chrome",    cfg / "google-chrome"),
+            ("chrome",  "Chrome Beta", cfg / "google-chrome-beta"),
+            ("chrome",  "Chromium",  cfg / "chromium"),
+            ("edge",    "Edge",      cfg / "microsoft-edge"),
+            ("brave",   "Brave",
+              cfg / "BraveSoftware/Brave-Browser"),
+            ("vivaldi", "Vivaldi",   cfg / "vivaldi"),
+            ("opera",   "Opera",     cfg / "opera"),
+        ]
+        # snap + flatpak sandboxed paths
+        snap = home / "snap"
+        out += [
+            ("chrome",  "Chromium (snap)",
+              snap / "chromium/common/chromium"),
+        ]
+        flat = home / ".var/app"
+        out += [
+            ("chrome",  "Chromium (flatpak)",
+              flat / "org.chromium.Chromium/config/chromium"),
+            ("brave",   "Brave (flatpak)",
+              flat / "com.brave.Browser/config/BraveSoftware/"
+                      "Brave-Browser"),
+        ]
+    elif p == "win32":
+        local   = Path(os.environ.get("LOCALAPPDATA", str(home)))
+        roaming = Path(os.environ.get("APPDATA",      str(home)))
+        out += [
+            ("chrome",  "Chrome",
+              local / "Google/Chrome/User Data"),
+            ("chrome",  "Chromium",
+              local / "Chromium/User Data"),
+            ("edge",    "Edge",
+              local / "Microsoft/Edge/User Data"),
+            ("brave",   "Brave",
+              local / "BraveSoftware/Brave-Browser/User Data"),
+            ("vivaldi", "Vivaldi",
+              local / "Vivaldi/User Data"),
+            ("opera",   "Opera",
+              roaming / "Opera Software/Opera Stable"),
+        ]
+        _ = roaming   # quiet linter; reserved for future use
+    return out
+
+
+def _firefox_roots() -> List[Path]:
+    """Return list of Firefox-family base directories (Mozilla/Firefox
+    or equivalent) for the current OS. The actual profile lives one
+    or two levels deeper."""
+    home = Path.home()
+    p = sys.platform
+    if p == "darwin":
+        base = home / "Library/Application Support"
+        return [
+            base / "Firefox",
+            base / "Firefox Developer Edition",
+            base / "Firefox Nightly",
+        ]
+    if p.startswith("linux"):
+        out = [
+            home / ".mozilla/firefox",
+            home / "snap/firefox/common/.mozilla/firefox",
+            home / ".var/app/org.mozilla.firefox/.mozilla/firefox",
+        ]
+        return out
+    if p == "win32":
+        roaming = Path(os.environ.get("APPDATA", str(home)))
+        return [
+            roaming / "Mozilla/Firefox",
+            roaming / "Mozilla/Firefox Developer Edition",
+        ]
+    return []
+
+
+# ---------------------------------------------------------------- #
+#  Discovery                                                        #
+# ---------------------------------------------------------------- #
+def _iter_chromium() -> Iterator[Profile]:
+    for browser_id, browser_label, root in _chromium_roots():
+        if not root.is_dir():
+            continue
+        for prof_dir in sorted(root.iterdir()):
+            if not prof_dir.is_dir():
+                continue
+            name = prof_dir.name
+            if name not in ("Default",) and not name.startswith("Profile"):
+                continue
+            hist = prof_dir / "History"
+            if hist.is_file():
+                yield Profile(
+                    family       = CHROMIUM,
+                    browser      = browser_id,
+                    profile_id   = f"{browser_label}/{name}",
+                    history_path = hist,
+                )
+
+
+def _iter_firefox() -> Iterator[Profile]:
+    for root in _firefox_roots():
+        if not root.is_dir():
+            continue
+        # profiles.ini tells us which directories Firefox itself
+        # treats as profiles. Falling back to a glob in case the ini
+        # is missing or stale.
+        seen: set = set()
+        ini = root / "profiles.ini"
+        if ini.is_file():
+            try:
+                cfg = configparser.ConfigParser()
+                cfg.read(ini, encoding="utf-8")
+                for section in cfg.sections():
+                    if not section.startswith("Profile"):
+                        continue
+                    rel = cfg.get(section, "Path", fallback="")
+                    if not rel:
+                        continue
+                    is_relative = cfg.get(section, "IsRelative",
+                                            fallback="1") == "1"
+                    p = (root / rel) if is_relative else Path(rel)
+                    if p.is_dir():
+                        seen.add(p.resolve())
+            except (configparser.Error, OSError):
+                pass
+
+        profiles_root = root / "Profiles"
+        if profiles_root.is_dir():
+            for prof_dir in profiles_root.iterdir():
+                if prof_dir.is_dir():
+                    seen.add(prof_dir.resolve())
+
+        for prof_dir in sorted(seen):
+            hist = prof_dir / "places.sqlite"
+            if hist.is_file():
+                yield Profile(
+                    family       = FIREFOX,
+                    browser      = "firefox",
+                    profile_id   = f"Firefox/{prof_dir.name}",
+                    history_path = hist,
+                )
+
+
+def discover_profiles(
+    browser_filter: List[str] = None) -> List[Profile]:
+    """Return every profile we can see on this machine. Optional
+    `browser_filter` keeps only matching browser ids (e.g.
+    ['chrome', 'firefox'])."""
+    result: List[Profile] = []
+    for p in _iter_chromium():
+        result.append(p)
+    for p in _iter_firefox():
+        result.append(p)
+    if browser_filter:
+        keep = {b.strip().lower() for b in browser_filter if b.strip()}
+        result = [p for p in result if p.browser in keep]
+    return result

browser_sync/state.py

@@ -0,0 +1,130 @@
+"""Memory backend for browser-sync. Same template as the sibling
+connector packages — read-write to EvolutionDB via psycopg over the
+PostgreSQL wire protocol. The browser sync stores one row per
+unique URL per profile (keyed by sha1 of the URL) and one
+per-profile watermark holding the ISO timestamp of the most recent
+visit it has already imported."""
+from __future__ import annotations
+
+import json
+import sys
+import time
+from typing import Dict, Optional
+
+
+def _e(s: str) -> str:
+    if not isinstance(s, str):
+        s = str(s)
+    s = s.replace("\r", " ").replace("\n", " ").replace("\t", " ")
+    return s.replace("'", "''")
+
+
+def _parse_value(raw):
+    if isinstance(raw, dict):
+        return raw
+    if not raw:
+        return {}
+    try:
+        return json.loads(raw)
+    except (TypeError, ValueError):
+        return {}
+
+
+class MemoryStore:
+    _RECONNECT_ATTEMPTS    = 3
+    _RECONNECT_BACKOFF_SEC = 0.5
+
+    def __init__(self, host: str, port: int, user: str, password: str,
+                 database: str, store: str, namespace: str):
+        try:
+            import psycopg
+        except ImportError as exc:
+            raise RuntimeError(
+                "evolutiondb-browser-sync requires psycopg. Install "
+                "with `pip install psycopg[binary]>=3.1`.") from exc
+
+        self.psycopg = psycopg
+        self._conn_kwargs = dict(
+            host=host, port=port, user=user, password=password,
+            dbname=database, autocommit=True,
+        )
+        self.store     = store
+        self.namespace = namespace
+        self.conn      = self._connect()
+
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute(f"CREATE MEMORY STORE {self.store}")
+        except Exception:
+            pass
+
+    def _connect(self):
+        return self.psycopg.connect(**self._conn_kwargs)
+
+    def _is_dead(self, exc: BaseException) -> bool:
+        return isinstance(exc, (self.psycopg.OperationalError,
+                                  self.psycopg.InterfaceError))
+
+    def _retry(self, fn):
+        last = None
+        for attempt in range(self._RECONNECT_ATTEMPTS):
+            try:
+                with self.conn.cursor() as cur:
+                    return fn(cur)
+            except Exception as exc:
+                if not self._is_dead(exc):
+                    raise
+                last = exc
+                print(f"[browser-sync] db connection lost "
+                      f"(attempt {attempt + 1}): {exc}",
+                      file=sys.stderr, flush=True)
+                try:
+                    self.conn.close()
+                except Exception:
+                    pass
+                if attempt + 1 < self._RECONNECT_ATTEMPTS:
+                    time.sleep(self._RECONNECT_BACKOFF_SEC *
+                                (attempt + 1))
+                    try:
+                        self.conn = self._connect()
+                    except Exception as reconn:
+                        last = reconn
+                        continue
+        raise last  # type: ignore[misc]
+
+    # ---------- watermark (per-profile) ----------
+    @staticmethod
+    def _wm_key(profile_id: str) -> str:
+        safe = profile_id.replace("/", "_").replace(" ", "_")
+        return f"browser_state_{safe}"
+
+    def get_watermark_iso(self, profile_id: str) -> Optional[str]:
+        key = self._wm_key(profile_id)
+
+        def run(cur):
+            cur.execute(
+                f"SELECT mem_value FROM __mem_{self.store} "
+                f"WHERE mem_namespace = '{_e(self.namespace)}' "
+                f"AND mem_key = '{_e(key)}'")
+            rows = cur.fetchall()
+            if not rows:
+                return None
+            v = _parse_value(rows[0][0]).get("last_visited_at")
+            return str(v) if v else None
+        return self._retry(run)
+
+    def set_watermark_iso(self, profile_id: str,
+                           last_iso: str) -> None:
+        key = self._wm_key(profile_id)
+        value = json.dumps({"last_visited_at": last_iso,
+                              "saved_at":         time.time()})
+        self._retry(lambda cur: cur.execute(
+            f"MEMORY PUT INTO {self.store} VALUES "
+            f"('{_e(self.namespace)}','{_e(key)}','{_e(value)}')"))
+
+    # ---------- records ----------
+    def put_record(self, key: str, record: Dict) -> None:
+        value = json.dumps(record, ensure_ascii=False)
+        self._retry(lambda cur: cur.execute(
+            f"MEMORY PUT INTO {self.store} VALUES "
+            f"('{_e(self.namespace)}','{_e(key)}','{_e(value)}')"))

browser_sync/sync.py

@@ -0,0 +1,228 @@
+"""
+evolutiondb-browser-sync — daemon that snapshots local browser
+history and pours visit records into the evolutiondb-memory store.
+
+Modes
+-----
+  --once               one sync pass over every discovered profile,
+                       then exit.
+  --interval SECONDS   daemon mode. Each pass is incremental.
+  --since "30d"        first-run wall-clock floor when the profile
+                       has no stored watermark.
+  --browser chrome,edge,firefox
+                       restrict to a subset of browsers.
+  --dry-run            do everything except write to memory.
+
+No --auth subcommand exists. Browser history lives in files the
+user already owns, so there is no OAuth flow to start.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import signal
+import sys
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from . import scanner as scan_mod
+from . import extract as ext_mod
+from . import state   as state_mod
+
+
+# ---------------------------------------------------------------- #
+#  Config + .env loader (same shape as sibling syncs)               #
+# ---------------------------------------------------------------- #
+def _load_dotenv(path: Path) -> None:
+    if not path.exists():
+        return
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        k, v = k.strip(), v.strip().strip('"').strip("'")
+        if v:
+            os.environ.setdefault(k, v)
+
+
+class Config:
+    def __init__(self):
+        self.evosql_host = os.environ.get("EVOSQL_HOST",     "127.0.0.1")
+        self.evosql_port = int(os.environ.get("EVOSQL_PORT", "5433"))
+        self.evosql_user = os.environ.get("EVOSQL_USER",     "admin")
+        self.evosql_pass = os.environ.get("EVOSQL_PASSWORD", "admin")
+        self.evosql_db   = os.environ.get("EVOSQL_DATABASE", "evosql")
+        self.user_id     = os.environ.get("MCP_USER_ID",
+                                            "default_user")
+        self.store       = os.environ.get("BROWSER_MEMORY_STORE",
+                                            "mcp_mem")
+        self.poll_secs   = int(os.environ.get("BROWSER_POLL_INTERVAL",
+                                                "1800"))
+
+
+_SINCE_RE = re.compile(r"^\s*(\d+)\s*([smhdw])\s*$", re.I)
+
+
+def parse_since(text: str) -> str:
+    m = _SINCE_RE.match(text)
+    if not m:
+        raise ValueError(
+            f"--since must be like '1h', '7d', got {text!r}")
+    n, unit = int(m.group(1)), m.group(2).lower()
+    delta = {
+        "s": timedelta(seconds=n),
+        "m": timedelta(minutes=n),
+        "h": timedelta(hours=n),
+        "d": timedelta(days=n),
+        "w": timedelta(weeks=n),
+    }[unit]
+    return (datetime.now(timezone.utc) - delta).isoformat(
+        timespec="seconds").replace("+00:00", "Z")
+
+
+# ---------------------------------------------------------------- #
+#  Pass                                                             #
+# ---------------------------------------------------------------- #
+def _record_key(record: Dict) -> str:
+    """Stable per (browser, profile, url) key so re-syncing the same
+    URL upserts the watermark / visit_count instead of multiplying
+    rows in the memory store."""
+    profile_slug = (record["profile"]
+                    .replace("/", "_").replace(" ", "_"))
+    return (f"browser_visit_{record['browser']}_"
+              f"{profile_slug}_{record['url_hash']}")
+
+
+def sync_once(cfg: Config, *, since_iso: Optional[str],
+                browser_filter: Optional[List[str]],
+                dry_run: bool = False) -> Dict[str, int]:
+    profiles = scan_mod.discover_profiles(browser_filter)
+    counters = {"profiles": 0, "visits": 0,
+                 "skipped":  0, "errors": 0}
+
+    store: Optional[state_mod.MemoryStore]
+    if dry_run:
+        store = None
+    else:
+        store = state_mod.MemoryStore(
+            host=cfg.evosql_host, port=cfg.evosql_port,
+            user=cfg.evosql_user, password=cfg.evosql_pass,
+            database=cfg.evosql_db, store=cfg.store,
+            namespace=cfg.user_id,
+        )
+
+    for prof in profiles:
+        counters["profiles"] += 1
+        wm = (store.get_watermark_iso(prof.profile_id)
+              if store else None)
+        floor = wm or since_iso
+        latest = floor or ""
+        try:
+            for record in ext_mod.iter_visits(prof, since_iso=floor):
+                key = _record_key(record)
+                if store:
+                    store.put_record(key, record)
+                counters["visits"] += 1
+                if record["last_visited_at"] > latest:
+                    latest = record["last_visited_at"]
+        except Exception as exc:  # noqa: BLE001
+            print(f"[browser-sync] {prof.profile_id} failed: {exc}",
+                  file=sys.stderr, flush=True)
+            counters["errors"] += 1
+            continue
+        if store and latest and latest != (wm or ""):
+            store.set_watermark_iso(prof.profile_id, latest)
+
+    return counters
+
+
+# ---------------------------------------------------------------- #
+#  Signals                                                          #
+# ---------------------------------------------------------------- #
+_stop = False
+
+
+def _install_signal_handlers() -> None:
+    def _handler(_signum, _frame):
+        global _stop
+        _stop = True
+        print("[browser-sync] stop requested, finishing current pass",
+              file=sys.stderr, flush=True)
+    for s in (signal.SIGTERM, signal.SIGINT):
+        try:
+            signal.signal(s, _handler)
+        except (ValueError, OSError):
+            pass
+
+
+# ---------------------------------------------------------------- #
+#  CLI                                                              #
+# ---------------------------------------------------------------- #
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="evolutiondb-browser-sync",
+        description="Sync browser history into EvolutionDB memory.")
+    parser.add_argument("--once",     action="store_true")
+    parser.add_argument("--interval", type=int)
+    parser.add_argument("--since",    default="7d")
+    parser.add_argument("--browser",  default="",
+        help="Comma list (chrome,edge,firefox,brave,arc,vivaldi,"
+             "opera). Empty means every detected browser.")
+    parser.add_argument("--list",     action="store_true",
+        help="Print every detected profile and exit.")
+    parser.add_argument("--dry-run",  action="store_true")
+    parser.add_argument("--env-file", default=".env")
+    args = parser.parse_args(argv)
+
+    _load_dotenv(Path(args.env_file).expanduser())
+
+    browser_filter = (
+        [b for b in args.browser.split(",") if b.strip()]
+        if args.browser else None)
+
+    if args.list:
+        profiles = scan_mod.discover_profiles(browser_filter)
+        for p in profiles:
+            print(f"{p.browser:10s} {p.profile_id:40s} "
+                  f"{p.history_path}")
+        if not profiles:
+            print("(no profiles detected)")
+        return 0
+
+    try:
+        since_iso = parse_since(args.since)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    cfg = Config()
+    _install_signal_handlers()
+
+    def run_pass() -> int:
+        try:
+            counts = sync_once(cfg, since_iso=since_iso,
+                                 browser_filter=browser_filter,
+                                 dry_run=args.dry_run)
+            print(json.dumps({"ok": True, **counts}), flush=True)
+            return 0
+        except Exception as exc:  # noqa: BLE001
+            print(json.dumps({"ok": False, "error": str(exc)}),
+                  flush=True)
+            return 4
+
+    if args.once or not args.interval:
+        return run_pass()
+
+    interval = max(60, int(args.interval))
+    rc = 0
+    while not _stop:
+        rc = run_pass()
+        for _ in range(interval):
+            if _stop:
+                break
+            time.sleep(1)
+    return rc

evolutiondb_browser_sync-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: evolutiondb-browser-sync
+Version: 0.1.0
+Summary: Sync browser history (Chrome, Edge, Firefox) into EvolutionDB long-term memory.
+Author-email: alptekin topal <topal.alptekin@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/alptekin/evolutiondb
+Project-URL: Repository, https://github.com/alptekin/evolutiondb
+Project-URL: Source, https://github.com/alptekin/evolutiondb/tree/main/client/browser-sync
+Project-URL: Issues, https://github.com/alptekin/evolutiondb/issues
+Keywords: evolutiondb,browser,history,chrome,edge,firefox,long-term-memory,agent-memory,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Requires-Python: >=3.9
+Requires-Dist: psycopg[binary]>=3.1

evolutiondb_browser_sync-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+browser_sync/__init__.py,sha256=Q_VVL-1Ove9j8DowqW0AYIa2QQbROunVMW0xq6MPv6g,413
+browser_sync/__main__.py,sha256=8Ap-X_Be9dePdOFaAWS6BNHL2kg3FQHkMgQ6Hufk7jg,80
+browser_sync/extract.py,sha256=10xCWtSADqBuRmjfNJldstnAw3ih_t3DAzTxIEc4yBQ,7972
+browser_sync/scanner.py,sha256=xj_quelH4sJL4uxiA83XEPIZy4xeBSuDuns4aYuwQvI,8328
+browser_sync/state.py,sha256=5BnSiTKwENvEyIUunFhCfUT7_4Q5Mv7gnOZBslEXUOY,4553
+browser_sync/sync.py,sha256=JESNnblQSEB7IKwKma9AfH5Bi9th6FedZLJciEXPzBQ,8215
+evolutiondb_browser_sync-0.1.0.dist-info/METADATA,sha256=k4lxKp2up8lSfdqu7KLs-62f7wyuSHWuP9KxsELP23Q,1408
+evolutiondb_browser_sync-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+evolutiondb_browser_sync-0.1.0.dist-info/entry_points.txt,sha256=8CbFmjK0Ls5Usp86mI_VNCT2PHL3bmtJifBFZpLfc2M,72
+evolutiondb_browser_sync-0.1.0.dist-info/top_level.txt,sha256=ZOT504CJKp9k-UKUagrC2S2-YZkSVCiGOfMzwbkcgFg,13
+evolutiondb_browser_sync-0.1.0.dist-info/RECORD,,

evolutiondb_browser_sync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

evolutiondb_browser_sync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+evolutiondb-browser-sync = browser_sync.__main__:main

evolutiondb_browser_sync-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+browser_sync