contextbase-plugin-chrome-local 0.2.4__py3-none-any.whl

contextbase_plugin_chrome_local-0.2.4.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: contextbase-plugin-chrome-local
+Version: 0.2.4
+Summary: Chrome local plugin for ContextBase
+Author: Alizain Feerasta
+Author-email: Alizain Feerasta <alizain.feerasta@gmail.com>
+Requires-Dist: contextbase-shared-plugins==0.2.4
+Requires-Dist: dagster==1.12.14
+Requires-Dist: dagster-dlt==0.28.14
+Requires-Dist: dlt>=1.26.0
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Python: >=3.14, <3.15

contextbase_plugin_chrome_local-0.2.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+plugin_chrome_local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_chrome_local/binding_config.py,sha256=p_l7z-2oCMivd_8-H6T9uReOJUslfAsR8O6WBd7NHS0,1498
+plugin_chrome_local/component.py,sha256=a542jdao0HU-BHgW6MbD2O0hPKnwgSurzAgiXqXxbxM,4063
+plugin_chrome_local/defs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_chrome_local/defs/defs.yaml,sha256=IYKSc6UTq-426pzOmauAZbwFrMJJB1XplhDGIbEW850,61
+plugin_chrome_local/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_chrome_local/models/base.py,sha256=Fp7n4EfxQOxzqm34-D-rYyu60P88eZUIewCBNP_Iuc4,119
+plugin_chrome_local/models/ctx.py,sha256=ugppXE8Y2Cux9yz26AqzBLY58Q_kX8W7QZ910jhY1cQ,754
+plugin_chrome_local/models/ingress.py,sha256=fU1WpaRUijJKF3cA4-sGXEmIt2uFYilcr6BIoxlAkck,1588
+plugin_chrome_local/models/translators.py,sha256=Q70Xkb54ZB8T4lecklRDypxbKGlxuVlY_bDkPtt6JDs,2010
+plugin_chrome_local/models/types.py,sha256=u2Y5SHZdK-_SFOg254UDtAD7tdZ5FjnbY6tsxjlp0ys,68
+plugin_chrome_local/plugin.json,sha256=ntgpILrXGIkOnaeWMSgFv_DAS58MVKG4A3yfr3DkzDQ,85
+plugin_chrome_local/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_chrome_local/sources/snapshot.py,sha256=kgVe6kx86vna-FCiEiAteaNnCjL2twy5grB8wU4TL8g,10477
+contextbase_plugin_chrome_local-0.2.4.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
+contextbase_plugin_chrome_local-0.2.4.dist-info/METADATA,sha256=y5jVuyAhKZjWQc0GLaU2nQckGbm5rYWNrF4TqxLRKEo,445
+contextbase_plugin_chrome_local-0.2.4.dist-info/RECORD,,

contextbase_plugin_chrome_local-0.2.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.15
+Root-Is-Purelib: true
+Tag: py3-none-any

plugin_chrome_local/binding_config.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import Field, model_validator
+
+from shared_plugins.bindings import BaseBindingConfigModel, NonEmptyText, ResolvedPath
+
+
+class ChromeLocalDataDir(BaseBindingConfigModel):
+    name: NonEmptyText
+    path: ResolvedPath
+
+
+class ChromeLocalBindingConfig(BaseBindingConfigModel):
+    data_dirs: list[ChromeLocalDataDir] = Field(
+        default_factory=lambda: [
+            ChromeLocalDataDir(
+                name="chrome",
+                path=Path.home()
+                / "Library"
+                / "Application Support"
+                / "Google"
+                / "Chrome",
+            ),
+            ChromeLocalDataDir(
+                name="chrome_canary",
+                path=Path.home()
+                / "Library"
+                / "Application Support"
+                / "Google"
+                / "Chrome Canary",
+            ),
+        ],
+        min_length=1,
+    )
+
+    @model_validator(mode="after")
+    def _validate_unique_names(self) -> ChromeLocalBindingConfig:
+        duplicate_names = tuple(
+            name
+            for name in dict.fromkeys(data_dir.name for data_dir in self.data_dirs)
+            if sum(data_dir.name == name for data_dir in self.data_dirs) > 1
+        )
+        if duplicate_names:
+            duplicates = ", ".join(duplicate_names)
+            raise ValueError(
+                f"data_dirs names must be unique; duplicates: {duplicates}."
+            )
+        return self

plugin_chrome_local/component.py

@@ -0,0 +1,120 @@
+import dagster as dg
+from dagster import AssetExecutionContext
+from dagster_dlt import DagsterDltResource
+from shared_plugins.automation import non_overlapping_automation_condition
+from shared_plugins.bindings import (
+    parse_binding_config,
+    resolve_binding_models,
+)
+from shared_plugins.control_plane import ControlPlaneClient
+from shared_plugins.dlt import resolve_partition_binding, run_dlt_pipeline
+from shared_plugins.naming import (
+    dagster_asset_group_name,
+    dagster_asset_tags,
+    dagster_dlt_asset_key,
+    dagster_partition_def_name,
+    dagster_pool_name,
+    dlt_source_name,
+    plugin_id_from_module,
+)
+from shared_plugins.resources import DLT_RESOURCE
+
+from .binding_config import ChromeLocalBindingConfig
+from .sources.snapshot import SUPPORTED_MODEL_NAMES, chrome_local_snapshot_source
+
+PLUGIN_ID = plugin_id_from_module(__file__)
+SNAPSHOT_JOB = "snapshot"
+SNAPSHOT_SOURCE_NAME = dlt_source_name(PLUGIN_ID, SNAPSHOT_JOB)
+
+
+def _build_snapshot_specs(
+    partitions_def: dg.PartitionsDefinition,
+    automation_condition: dg.AutomationCondition,
+) -> list[dg.AssetSpec]:
+    shared = dict(
+        group_name=dagster_asset_group_name(PLUGIN_ID),
+        tags=dagster_asset_tags(PLUGIN_ID),
+        automation_condition=automation_condition,
+        partitions_def=partitions_def,
+    )
+
+    visit_key = dagster_dlt_asset_key(SNAPSHOT_SOURCE_NAME, "visit")
+    bookmark_key = dagster_dlt_asset_key(SNAPSHOT_SOURCE_NAME, "bookmark")
+
+    return [
+        dg.AssetSpec(
+            key=visit_key,
+            **shared,
+        ),
+        dg.AssetSpec(
+            key=bookmark_key,
+            **shared,
+        ),
+    ]
+
+
+class ChromeLocalSyncComponent(dg.Component):
+    def build_defs(self, context: dg.ComponentLoadContext) -> dg.Definitions:
+        partitions_def = dg.DynamicPartitionsDefinition(
+            name=dagster_partition_def_name(PLUGIN_ID)
+        )
+
+        snapshot_specs = _build_snapshot_specs(
+            partitions_def=partitions_def,
+            automation_condition=non_overlapping_automation_condition(
+                dg.AutomationCondition.on_missing()
+                | dg.AutomationCondition.on_cron("*/15 * * * *")
+            ),
+        )
+
+        @dg.multi_asset(
+            specs=snapshot_specs,
+            can_subset=True,
+            name="chrome_local_snapshot",
+            pool=dagster_pool_name(PLUGIN_ID),
+        )
+        def chrome_local_snapshot_assets(
+            context: AssetExecutionContext,
+            dlt_resource: DagsterDltResource,
+            control_plane: dg.ResourceParam[ControlPlaneClient],
+        ):
+            binding = resolve_partition_binding(
+                context=context,
+                control_plane=control_plane,
+                plugin_id=PLUGIN_ID,
+            )
+            binding_id = str(binding.binding_id)
+            cfg = parse_binding_config(binding, ChromeLocalBindingConfig)
+            binding_models = resolve_binding_models(
+                binding,
+                supported_models=SUPPORTED_MODEL_NAMES,
+                default_active=SUPPORTED_MODEL_NAMES,
+            )
+            source = chrome_local_snapshot_source(
+                binding_id,
+                cfg,
+                binding_models=binding_models,
+            )
+            yield from run_dlt_pipeline(
+                context=context,
+                dlt_resource=dlt_resource,
+                source=source,
+                plugin_id=PLUGIN_ID,
+                binding_id=binding_id,
+                job_name=SNAPSHOT_JOB,
+            )
+
+        automation_sensor = dg.AutomationConditionSensorDefinition(
+            name="chrome_local_automation_sensor",
+            target=dg.AssetSelection.assets(chrome_local_snapshot_assets),
+            default_status=dg.DefaultSensorStatus.RUNNING,
+            minimum_interval_seconds=30,
+        )
+
+        return dg.Definitions(
+            assets=[chrome_local_snapshot_assets],
+            sensors=[automation_sensor],
+            resources={
+                "dlt_resource": DLT_RESOURCE,
+            },
+        )

plugin_chrome_local/defs/defs.yaml

@@ -0,0 +1 @@
+type: plugin_chrome_local.component.ChromeLocalSyncComponent

plugin_chrome_local/models/base.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass

plugin_chrome_local/models/ctx.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from pydantic import AwareDatetime
+from shared_plugins.models import CtxModel, IdStr, NonNegativeInt
+
+
+class VisitRow(CtxModel):
+    profile: IdStr
+    visit_id: NonNegativeInt
+    url: str | None = None
+    title: str | None = None
+    visit_time: AwareDatetime | None = None
+    visit_duration_ms: NonNegativeInt | None = None
+    url_visit_count: NonNegativeInt | None = None
+    url_typed_count: NonNegativeInt | None = None
+    transition_type: int | None = None
+
+
+class BookmarkRow(CtxModel):
+    profile: IdStr
+    id: IdStr
+    guid: str | None = None
+    name: str | None = None
+    url: IdStr
+    folder_path: IdStr
+    date_added: AwareDatetime | None = None
+    date_last_used: AwareDatetime | None = None

plugin_chrome_local/models/ingress.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Literal
+
+from pydantic import Field, StrictStr
+from shared_plugins.models import IdStr, IngressModel
+from shared_plugins.sqlalchemy_types import ChromiumTimestamp
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .base import Base
+from .types import RawTimestamp
+
+
+class ChromeProfileIngress(IngressModel):
+    name: IdStr
+    dir_path: IdStr
+
+
+class ChromeUrl(Base):
+    """Row from urls table in Chrome History database."""
+
+    __tablename__ = "urls"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    url: Mapped[str | None] = mapped_column(String)
+    title: Mapped[str | None] = mapped_column(String)
+    visit_count: Mapped[int | None]
+    typed_count: Mapped[int | None]
+
+
+class ChromeVisit(Base):
+    """Row from visits table in Chrome History database."""
+
+    __tablename__ = "visits"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    url_id: Mapped[int] = mapped_column("url", ForeignKey("urls.id"))
+    visit_time: Mapped[datetime | None] = mapped_column(ChromiumTimestamp())
+    visit_duration: Mapped[int | None]
+    transition: Mapped[int | None]
+
+    url_entry: Mapped[ChromeUrl] = relationship()
+
+
+class ChromeBookmarkIngress(IngressModel):
+    type: Literal["url"]
+    profile: IdStr
+    id: IdStr
+    guid: StrictStr | None = None
+    name: StrictStr | None = None
+    url: StrictStr = Field(min_length=1)
+    folder_path: IdStr
+    date_added: RawTimestamp = None
+    date_last_used: RawTimestamp = None

plugin_chrome_local/models/translators.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from datetime import datetime, timedelta
+
+from shared_plugins.sqlalchemy_types import CHROMIUM_EPOCH
+
+from .ctx import BookmarkRow, VisitRow
+from .ingress import ChromeBookmarkIngress, ChromeVisit
+
+
+def _chromium_to_datetime(
+    *,
+    value: int | str | None,
+) -> datetime | None:
+    if value is None:
+        return None
+
+    return CHROMIUM_EPOCH + timedelta(microseconds=int(value))
+
+
+def visits_to_ctx_models(
+    *,
+    binding_id: str,
+    profile: str,
+    visits: Iterable[ChromeVisit],
+) -> Iterator[VisitRow]:
+    for visit in visits:
+        yield VisitRow(
+            ctx_binding_id=binding_id,
+            ctx_source_updated_at=visit.visit_time,
+            profile=profile,
+            visit_id=visit.id,
+            url=visit.url_entry.url,
+            title=visit.url_entry.title,
+            visit_time=visit.visit_time,
+            visit_duration_ms=visit.visit_duration,
+            url_visit_count=visit.url_entry.visit_count,
+            url_typed_count=visit.url_entry.typed_count,
+            transition_type=visit.transition,
+        )
+
+
+def bookmarks_to_ctx_models(
+    *,
+    binding_id: str,
+    bookmarks: Iterable[ChromeBookmarkIngress],
+) -> Iterator[BookmarkRow]:
+    for bookmark in bookmarks:
+        date_added = _chromium_to_datetime(
+            value=bookmark.date_added,
+        )
+        date_last_used = _chromium_to_datetime(
+            value=bookmark.date_last_used,
+        )
+        source_updated_at = date_last_used if date_last_used is not None else date_added
+        yield BookmarkRow(
+            ctx_binding_id=binding_id,
+            ctx_source_updated_at=source_updated_at,
+            profile=bookmark.profile,
+            id=bookmark.id,
+            guid=bookmark.guid,
+            name=bookmark.name,
+            url=bookmark.url,
+            folder_path=bookmark.folder_path,
+            date_added=date_added,
+            date_last_used=date_last_used,
+        )

plugin_chrome_local/models/types.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+RawTimestamp = int | str | None

plugin_chrome_local/plugin.json

@@ -0,0 +1,7 @@
+{
+	"auth": {
+		"type": "none"
+	},
+	"mode": "dagster",
+	"plugin_id": "chrome_local"
+}

plugin_chrome_local/sources/snapshot.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import dlt
+from pydantic import ValidationError
+from shared_plugins.bindings import ResolvedBindingModels, iter_active_model_rows
+from shared_plugins.models import format_validation_error
+from shared_plugins.naming import (
+    dlt_resource_name,
+    dlt_source_name,
+    plugin_id_from_module,
+)
+from shared_plugins.resources import ctx_dlt_resource
+from shared_plugins.sqlite import sqlite_snapshot
+from sqlalchemy import create_engine, select
+from sqlalchemy.orm import Session, joinedload
+
+from ..binding_config import ChromeLocalBindingConfig, ChromeLocalDataDir
+from ..models.ctx import BookmarkRow, VisitRow
+from ..models.ingress import (
+    ChromeBookmarkIngress,
+    ChromeProfileIngress,
+    ChromeVisit,
+)
+from ..models.translators import bookmarks_to_ctx_models, visits_to_ctx_models
+
+PLUGIN_ID = plugin_id_from_module(__file__)
+JOB = "snapshot"
+LOGGER = logging.getLogger(__name__)
+SUPPORTED_MODEL_NAMES = ("visit", "bookmark")
+ROOT_FOLDERS = ("bookmark_bar", "other", "synced")
+MERGE_WRITE_DISPOSITION = {"disposition": "merge", "strategy": "delete-insert"}
+MERGE_KEY = ("_ctx_binding_id",)
+
+
+@dataclass(frozen=True)
+class BookmarkSkip:
+    profile: str
+    id: object
+    guid: object
+    name: object
+    url: object
+    folder_path: str
+    reason: str
+    validation_error: str
+
+
+def discover_profiles(
+    data_dirs: Sequence[ChromeLocalDataDir],
+) -> list[ChromeProfileIngress]:
+    """Scan the configured Chromium data directories for profile subdirectories."""
+    profiles: list[ChromeProfileIngress] = []
+    for data_dir in data_dirs:
+        browser_prefix = data_dir.name
+        data_dir_path = data_dir.path
+        if not data_dir_path.is_dir():
+            continue
+        for child in sorted(data_dir_path.iterdir()):
+            if not child.is_dir():
+                continue
+            has_history = (child / "History").is_file()
+            has_bookmarks = (child / "Bookmarks").is_file()
+            if has_history or has_bookmarks:
+                profiles.append(
+                    ChromeProfileIngress.model_validate(
+                        {
+                            "name": f"{browser_prefix}/{child.name}",
+                            "dir_path": str(child),
+                        }
+                    )
+                )
+
+    if not profiles:
+        searched = ", ".join(str(d.path) for d in data_dirs)
+        raise RuntimeError(
+            f"No Chrome profiles found. "
+            f"Searched for subdirectories containing History or Bookmarks in: {searched}"
+        )
+
+    return profiles
+
+
+def _iter_profile_visits(profile: ChromeProfileIngress) -> Iterator[ChromeVisit]:
+    """Yield visit records from a single Chrome profile's History database."""
+    history_path = Path(profile.dir_path) / "History"
+    if not history_path.is_file():
+        return
+
+    with sqlite_snapshot(history_path) as snapshot_path:
+        engine = create_engine(f"sqlite:///{snapshot_path}")
+        try:
+            with Session(engine) as session:
+                query = select(ChromeVisit).options(joinedload(ChromeVisit.url_entry))
+                yield from session.scalars(query).unique()
+        finally:
+            engine.dispose()
+
+
+def append_folder(folder_path: str, child_folder_name: str | None) -> str:
+    if not child_folder_name:
+        return folder_path
+
+    return f"{folder_path}/{child_folder_name}"
+
+
+def _to_bookmark_record_candidate(
+    *,
+    profile_name: str,
+    node: Mapping[str, object],
+    folder_path: str,
+) -> ChromeBookmarkIngress | BookmarkSkip:
+    candidate = dict(node)
+    candidate["profile"] = profile_name
+    candidate["folder_path"] = folder_path
+
+    try:
+        return ChromeBookmarkIngress.model_validate(candidate)
+    except ValidationError as exc:
+        message = format_validation_error(exc)
+        if "url" in message:
+            return BookmarkSkip(
+                profile=profile_name,
+                id=node.get("id"),
+                guid=node.get("guid"),
+                name=node.get("name"),
+                url=node.get("url"),
+                folder_path=folder_path,
+                reason="invalid_url",
+                validation_error=message,
+            )
+        raise
+
+
+def _log_bookmark_skip(skip: BookmarkSkip) -> None:
+    LOGGER.warning(
+        "chrome_local.bookmark_skipped %s",
+        json.dumps(
+            {
+                "profile": skip.profile,
+                "id": skip.id,
+                "guid": skip.guid,
+                "name": skip.name,
+                "url": skip.url,
+                "folder_path": skip.folder_path,
+                "reason": skip.reason,
+                "validation_error": skip.validation_error,
+            },
+            sort_keys=True,
+            default=str,
+        ),
+    )
+
+
+def _walk_bookmark_node(
+    *,
+    profile_name: str,
+    node_value: object,
+    folder_path: str,
+    skipped_bookmarks: list[BookmarkSkip],
+) -> Iterator[ChromeBookmarkIngress]:
+    if not isinstance(node_value, Mapping):
+        return
+
+    node_type = node_value.get("type")
+    if node_type == "url":
+        bookmark_result = _to_bookmark_record_candidate(
+            profile_name=profile_name,
+            node=node_value,
+            folder_path=folder_path,
+        )
+        if isinstance(bookmark_result, BookmarkSkip):
+            _log_bookmark_skip(bookmark_result)
+            skipped_bookmarks.append(bookmark_result)
+            return
+        yield bookmark_result
+        return
+
+    if node_type != "folder":
+        return
+
+    children = node_value.get("children")
+    if not isinstance(children, list):
+        return
+
+    for child in children:
+        if not isinstance(child, Mapping):
+            continue
+
+        child_type = child.get("type")
+        if child_type == "folder":
+            child_name = child.get("name")
+            next_folder_path = append_folder(
+                folder_path,
+                child_name if isinstance(child_name, str) else None,
+            )
+            yield from _walk_bookmark_node(
+                profile_name=profile_name,
+                node_value=child,
+                folder_path=next_folder_path,
+                skipped_bookmarks=skipped_bookmarks,
+            )
+            continue
+
+        if child_type == "url":
+            bookmark_result = _to_bookmark_record_candidate(
+                profile_name=profile_name,
+                node=child,
+                folder_path=folder_path,
+            )
+            if isinstance(bookmark_result, BookmarkSkip):
+                _log_bookmark_skip(bookmark_result)
+                skipped_bookmarks.append(bookmark_result)
+                continue
+            yield bookmark_result
+
+
+def _load_profile_bookmarks(
+    profile: ChromeProfileIngress,
+) -> tuple[list[ChromeBookmarkIngress], list[BookmarkSkip]]:
+    bookmarks_path = Path(profile.dir_path) / "Bookmarks"
+
+    if not bookmarks_path.is_file():
+        return [], []
+
+    raw = bookmarks_path.read_text(encoding="utf-8")
+    parsed = json.loads(raw)
+
+    if not isinstance(parsed, Mapping):
+        raise RuntimeError("Chrome Bookmarks root must be a JSON object.")
+
+    roots = parsed.get("roots")
+    if not isinstance(roots, Mapping):
+        raise RuntimeError(
+            "Chrome Bookmarks JSON missing 'roots'; cannot extract bookmarks."
+        )
+
+    bookmarks: list[ChromeBookmarkIngress] = []
+    skipped_bookmarks: list[BookmarkSkip] = []
+    for root_folder in ROOT_FOLDERS:
+        root_folder_node = roots.get(root_folder)
+        if root_folder_node is None:
+            continue
+
+        bookmarks.extend(
+            _walk_bookmark_node(
+                profile_name=profile.name,
+                node_value=root_folder_node,
+                folder_path=root_folder,
+                skipped_bookmarks=skipped_bookmarks,
+            )
+        )
+
+    return bookmarks, skipped_bookmarks
+
+
+def _scan_chrome_bookmarks(
+    data_dirs: Sequence[ChromeLocalDataDir],
+) -> list[ChromeBookmarkIngress]:
+    profiles = discover_profiles(data_dirs)
+    bookmarks: list[ChromeBookmarkIngress] = []
+    skipped_bookmarks: list[BookmarkSkip] = []
+
+    for profile in profiles:
+        profile_bookmarks, profile_skips = _load_profile_bookmarks(profile)
+        bookmarks.extend(profile_bookmarks)
+        skipped_bookmarks.extend(profile_skips)
+
+    LOGGER.info(
+        "chrome_local.bookmarks_discovered profiles=%d bookmarks=%d skipped_bookmarks=%d",
+        len(profiles),
+        len(bookmarks),
+        len(skipped_bookmarks),
+    )
+
+    return bookmarks
+
+
+@dlt.source(name=dlt_source_name(PLUGIN_ID, JOB))
+def chrome_local_snapshot_source(
+    binding_id: str,
+    cfg: ChromeLocalBindingConfig,
+    *,
+    binding_models: ResolvedBindingModels,
+) -> tuple[Any, ...]:
+    """Chrome local profile snapshot for one binding."""
+    data_dirs = cfg.data_dirs
+
+    @ctx_dlt_resource(
+        name=dlt_resource_name("visit"),
+        write_disposition=MERGE_WRITE_DISPOSITION,
+        merge_key=MERGE_KEY,
+        primary_key=("_ctx_binding_id", "profile", "visit_id"),
+    )
+    def visit_resource() -> Iterator[VisitRow]:
+        if "visit" not in binding_models.active:
+            return
+
+        profiles = discover_profiles(data_dirs)
+        for profile in profiles:
+            yield from iter_active_model_rows(
+                model_name="visit",
+                rows=visits_to_ctx_models(
+                    binding_id=binding_id,
+                    profile=profile.name,
+                    visits=_iter_profile_visits(profile),
+                ),
+                binding_models=binding_models,
+            )
+
+    @ctx_dlt_resource(
+        name=dlt_resource_name("bookmark"),
+        write_disposition=MERGE_WRITE_DISPOSITION,
+        merge_key=MERGE_KEY,
+        primary_key=("_ctx_binding_id", "profile", "id"),
+    )
+    def bookmark_resource() -> Iterator[BookmarkRow]:
+        if "bookmark" not in binding_models.active:
+            return
+
+        yield from iter_active_model_rows(
+            model_name="bookmark",
+            rows=bookmarks_to_ctx_models(
+                binding_id=binding_id,
+                bookmarks=_scan_chrome_bookmarks(data_dirs),
+            ),
+            binding_models=binding_models,
+        )
+
+    return (
+        visit_resource,
+        bookmark_resource,
+    )