contextbase-core 0.0.0a1__py3-none-any.whl

contextbase_core-0.0.0a1.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.5
+Name: contextbase-core
+Version: 0.0.0a1
+Requires-Python: <3.13,>=3.12
+Requires-Dist: contextbase-plugin-asana==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-chrome-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-claude-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-clickup==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-codex-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-github==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-gmail==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-gong==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-google-calendar==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-granola==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-hubspot==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-icloud-tabs-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-imessage-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-intercom==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-jira==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-linear==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-microsoft-calendar==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-microsoft-mail==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-microsoft-planner-premium==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-notion==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-reminders-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-salesforce==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-slack==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-whatsapp-local==0.0.0-alpha-1
+Requires-Dist: contextbase-plugin-workflowy==0.0.0-alpha-1
+Requires-Dist: contextbase-shared-plugins==0.0.0-alpha-1
+Requires-Dist: dagster==1.12.14
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic-settings>=2.11.0

contextbase_core-0.0.0a1.dist-info/RECORD

@@ -0,0 +1,9 @@
+core/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+core/definitions.py,sha256=FvQnW_luoVSkt9ypvFYw47HsSuSVzqvnWd_F-kmUXhw,5950
+core/defs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/defs/binding_partitions.py,sha256=HTU9Nzp84M1qF7h2B8kzgKHqoldorBAqCZTzggWDVLk,2767
+core/defs/binding_sync_state.py,sha256=vUY8OsU6Q6pQFMhpuCn-y7eDNALbwkX9WLvp80IuClE,8196
+pyproject.toml,sha256=rKFyq3-MxUhxDdHe-k9VefWjIj0i1EDkWfXgZuMmIS0,3313
+contextbase_core-0.0.0a1.dist-info/METADATA,sha256=EGmDNHdx2quXObvskB5dP5xVJJhRdgzqZEnVloyDTQ4,1757
+contextbase_core-0.0.0a1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+contextbase_core-0.0.0a1.dist-info/RECORD,,

contextbase_core-0.0.0a1.dist-info/WHEEL

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

core/__init__.py

@@ -0,0 +1 @@
+

core/definitions.py

@@ -0,0 +1,147 @@
+from importlib import import_module
+from importlib.metadata import entry_points
+from pathlib import Path
+
+from dagster import (
+    Definitions,
+    ResourceDefinition,
+    build_defs_for_component,
+    definitions,
+    load_from_defs_folder,
+)
+
+from shared_plugins.base_platform import BasePlatformClient
+from shared_plugins.env import (
+    CTXB_BASE_ID_ENV_VAR,
+    CTX_PLATFORM_URL_ENV_VAR,
+    load_shared_python_settings,
+)
+from shared_plugins.machine_token import resolve_machine_token_auth
+from shared_plugins.provider_token import ProviderTokenClient, ProviderTokenSettings
+from shared_plugins.sentry import init_sentry
+
+# Initialize Sentry as early as possible. This module is the single entry every
+# Dagster process loads (daemon, per-run subprocess, per-step subprocess; see
+# base-cli dagster/command.ts DAGSTER_CORE_MODULE_NAME), so initializing here
+# self-arms error reporting in all of them. Idempotent within a process.
+init_sentry()
+
+# Plugins advertise their Component class via this entry-point group (one per
+# installed contextbase plugin). Discovery is dist-metadata based, so it works
+# identically for editable workspace installs and wheels in site-packages.
+PLUGIN_ENTRY_POINT_GROUP = "contextlayer.plugins"
+
+
+def _without_component_tree(definitions: Definitions) -> Definitions:
+    return Definitions(
+        assets=definitions.assets,
+        schedules=definitions.schedules,
+        sensors=definitions.sensors,
+        jobs=definitions.jobs,
+        resources=definitions.resources,
+        executor=definitions.executor,
+        loggers=definitions.loggers,
+        asset_checks=definitions.asset_checks,
+        metadata=definitions.metadata,
+    )
+
+
+def _load_core_defs() -> Definitions:
+    # core stays the single Dagster project. Its own defs (the binding-partitions
+    # sync sensor in core/defs/) are plain @dg.definitions functions, not a
+    # Component, so they load via load_from_defs_folder — which works even from
+    # the wheel because core force-includes its own pyproject.toml.
+    core_module = import_module("core")
+    package_file = core_module.__file__
+    if package_file is None:
+        raise RuntimeError(
+            "Cannot resolve core's package root: core.__file__ is missing."
+        )
+    return load_from_defs_folder(
+        path_within_project=Path(package_file).resolve().parent
+    )
+
+
+def _load_plugin_defs() -> list[Definitions]:
+    # Discover plugins from installed dist metadata (entry points), NOT by walking
+    # the filesystem for a Dagster-project layout. load_from_defs_folder needs an
+    # on-disk [tool.dg] pyproject that uv_build wheels do not ship adjacent in
+    # site-packages, so it silently returned 0 assets from installed wheels.
+    # build_defs_for_component builds a standalone ComponentLoadContext and is
+    # install-mode-independent. Do not revert plugins to load_from_defs_folder.
+    discovered = sorted(
+        entry_points(group=PLUGIN_ENTRY_POINT_GROUP),
+        key=lambda entry_point: entry_point.name,
+    )
+    return [
+        build_defs_for_component(entry_point.load()()) for entry_point in discovered
+    ]
+
+
+def _build_base_platform_client() -> BasePlatformClient:
+    settings = load_shared_python_settings()
+    if settings.ctx_platform_url is None:
+        raise RuntimeError(
+            f"{CTX_PLATFORM_URL_ENV_VAR} is not set; run via ctxb so the "
+            "platform URL is configured."
+        )
+    if settings.ctx_base_id is None:
+        raise RuntimeError(
+            f"{CTXB_BASE_ID_ENV_VAR} is not set; run via ctxb so the base id is "
+            "configured."
+        )
+
+    # resolve_machine_token_auth() is the presence-switch: machine creds set
+    # (platform-managed) -> every platform call carries the minted aud=ctx
+    # Bearer; none set (local dev) -> tokenless, the platform authorizes via
+    # its CTX_AUTH_SUB_ID trust-env mode; partial -> raises here, at run
+    # launch, like the URL/base-id guards above.
+    return BasePlatformClient(
+        platform_url=settings.ctx_platform_url,
+        base_id=settings.ctx_base_id,
+        auth=resolve_machine_token_auth(),
+    )
+
+
+def _build_provider_token_client() -> ProviderTokenClient:
+    # ProviderTokenSettings() reads the host-injected machine creds (CTX_WEB_URL /
+    # CTX_MACHINE_CLIENT_ID / CTX_MACHINE_CLIENT_SECRET) plus CTXB_SCRATCH_DIR
+    # (the deployment-shared token cache) and fails loud if any is missing or
+    # blank. Registered lazily below (twin of base_platform) so a read-only
+    # introspection load never demands the machine creds it won't use; the ~1h
+    # machine token lives in the shared cache, so redemptions reuse the
+    # deployment's one token instead of minting per run.
+    return ProviderTokenClient(ProviderTokenSettings())
+
+
+@definitions
+def defs():
+    merged = Definitions.merge(
+        _without_component_tree(_load_core_defs()),
+        *[_without_component_tree(plugin_defs) for plugin_defs in _load_plugin_defs()],
+    )
+
+    resources = dict(merged.resources or {})
+    # Lazy on purpose: building the client eagerly here would construct
+    # SharedPythonSettings (which requires CTXB_DATABASE_URL) during code-location
+    # load, making read-only introspection (assetNodes/runs) demand a warehouse URL
+    # it never uses. resource_fn runs only at execution. Do not revert to
+    # hardcoded_resource.
+    resources["base_platform"] = ResourceDefinition(
+        resource_fn=lambda _init_context: _build_base_platform_client()
+    )
+    resources["provider_token"] = ResourceDefinition(
+        resource_fn=lambda _init_context: _build_provider_token_client()
+    )
+
+    return Definitions(
+        assets=merged.assets,
+        schedules=merged.schedules,
+        sensors=merged.sensors,
+        jobs=merged.jobs,
+        resources=resources,
+        executor=merged.executor,
+        loggers=merged.loggers,
+        asset_checks=merged.asset_checks,
+        metadata=merged.metadata,
+    )

core/defs/binding_partitions.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+import dagster as dg
+from shared_plugins.base_platform import BasePlatformClient
+from shared_plugins.naming import dagster_partition_def_name
+
+PARTITION_SYNC_SENSOR_MIN_INTERVAL_SECONDS = 30
+BINDING_PARTITIONS_DEF_SUFFIX = "_bindings"
+
+
+@dg.sensor(
+    name="binding_partitions_sync_sensor",
+    minimum_interval_seconds=PARTITION_SYNC_SENSOR_MIN_INTERVAL_SECONDS,
+    default_status=dg.DefaultSensorStatus.RUNNING,
+)
+def binding_partitions_sync_sensor(
+    context: dg.SensorEvaluationContext,
+    base_platform: dg.ResourceParam[BasePlatformClient],
+) -> dg.SensorResult:
+    plan = base_platform.load_binding_plan()
+
+    active_binding_ids_by_partitions_def: dict[str, set[str]] = defaultdict(set)
+    for binding in plan.bindings:
+        partitions_def_name = dagster_partition_def_name(binding.plugin_id)
+        active_binding_ids_by_partitions_def[partitions_def_name].add(
+            binding.binding_id
+        )
+
+    known_partitions_defs = set(active_binding_ids_by_partitions_def)
+    repository_def = context.repository_def
+    if repository_def is not None:
+        for asset_key in repository_def.asset_graph.get_all_asset_keys():
+            partitions_def = repository_def.asset_graph.get(asset_key).partitions_def
+            if isinstance(partitions_def, dg.DynamicPartitionsDefinition):
+                if partitions_def.name.endswith(BINDING_PARTITIONS_DEF_SUFFIX):
+                    known_partitions_defs.add(partitions_def.name)
+
+    dynamic_partition_requests = []
+
+    for partitions_def_name in sorted(known_partitions_defs):
+        active_binding_ids = active_binding_ids_by_partitions_def.get(
+            partitions_def_name, set()
+        )
+        partitions_def = dg.DynamicPartitionsDefinition(name=partitions_def_name)
+        existing_partition_ids = set(
+            context.instance.get_dynamic_partitions(partitions_def_name)
+        )
+
+        partition_additions = sorted(active_binding_ids - existing_partition_ids)
+        partition_deletions = sorted(existing_partition_ids - active_binding_ids)
+
+        if partition_additions:
+            dynamic_partition_requests.append(
+                partitions_def.build_add_request(partition_additions)
+            )
+
+        if partition_deletions:
+            dynamic_partition_requests.append(
+                partitions_def.build_delete_request(partition_deletions)
+            )
+
+    if not dynamic_partition_requests:
+        return dg.SensorResult(skip_reason="No dynamic partition key changes.")
+
+    return dg.SensorResult(dynamic_partitions_requests=dynamic_partition_requests)
+
+
+@dg.definitions
+def defs() -> dg.Definitions:
+    return dg.Definitions(sensors=[binding_partitions_sync_sensor])

core/defs/binding_sync_state.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+import dagster as dg
+from base_client.sync_state import SyncStateInputBindingsValue
+from shared_plugins.base_platform import BasePlatformClient
+
+if TYPE_CHECKING:
+    from dagster._core.definitions.assets.graph.base_asset_graph import BaseAssetGraph
+
+# A binding's frontier/last_run are projected from the runs touching its plugin's
+# canonical (ctx_primary) sync assets, then reported up via base_platform.
+CTX_PRIMARY_TAG_KEY = "ctx_primary"
+CTX_PRIMARY_TAG_VALUE = "true"
+# Dagster's per-run partition tag; a binding-sync run carries its binding_id here.
+PARTITION_TAG_KEY = "dagster/partition"
+RUNS_PER_BINDING_LIMIT = 50
+
+
+@dataclass(frozen=True)
+class RunRecord:
+    """One Dagster run projected to the fields the fold needs (mirrors
+    state.ts's ``RunRecord``): the canonical asset keys it touched, its start
+    time in epoch seconds (``None`` until the run starts), and its status
+    surfaced verbatim."""
+
+    asset_keys: tuple[str, ...]
+    start_time: float | None
+    status: str
+
+
+def fold_binding_sync_state(
+    canonical_keys: frozenset[str],
+    runs: Sequence[RunRecord],
+) -> SyncStateInputBindingsValue:
+    """Fold one binding's runs (newest-first) against its plugin's canonical
+    asset keys into the published digest — a verbatim port of state.ts's
+    ``foldBindingState``.
+
+    ``frontier`` is conservative: the min, over the binding's *active* canonical
+    assets (those seen in the runs), of each asset's latest successful run;
+    ``None`` if any active asset has no success in view. ``last_run`` /
+    ``last_run_status`` come from the newest run touching any canonical asset, in
+    whatever status it is.
+    """
+    relevant = [
+        run for run in runs if any(key in canonical_keys for key in run.asset_keys)
+    ]
+    if not relevant:
+        return SyncStateInputBindingsValue(
+            frontier=None, last_run=None, last_run_status=None
+        )
+
+    latest = relevant[0]
+    last_run = None if latest.start_time is None else _epoch_to_utc(latest.start_time)
+    last_run_status = latest.status
+
+    active_keys = {
+        key for run in relevant for key in run.asset_keys if key in canonical_keys
+    }
+
+    frontier_seconds: float | None = None
+    for key in active_keys:
+        success = next(
+            (
+                run
+                for run in relevant
+                if run.status == dg.DagsterRunStatus.SUCCESS.value
+                and run.start_time is not None
+                and key in run.asset_keys
+            ),
+            None,
+        )
+        if success is None or success.start_time is None:
+            return SyncStateInputBindingsValue(
+                frontier=None, last_run=last_run, last_run_status=last_run_status
+            )
+        frontier_seconds = (
+            success.start_time
+            if frontier_seconds is None
+            else min(frontier_seconds, success.start_time)
+        )
+
+    return SyncStateInputBindingsValue(
+        frontier=None if frontier_seconds is None else _epoch_to_utc(frontier_seconds),
+        last_run=last_run,
+        last_run_status=last_run_status,
+    )
+
+
+def _epoch_to_utc(seconds: float) -> datetime:
+    return datetime.fromtimestamp(seconds, tz=timezone.utc)
+
+
+def _is_canonical(asset_graph: BaseAssetGraph, asset_key: dg.AssetKey) -> bool:
+    # A selection key absent from the live graph (its plugin removed/renamed
+    # between the run finishing and this sensor firing) is simply not canonical —
+    # matching state.ts, which only membership-tests selection keys and never
+    # looks them up. A bare asset_graph.get() would raise KeyError, and since
+    # run-status sensors share a cursor, a throwing tick would stall digest
+    # reporting for every binding, not just this one.
+    if not asset_graph.has(asset_key):
+        return False
+    tags = asset_graph.get(asset_key).tags
+    return tags.get(CTX_PRIMARY_TAG_KEY) == CTX_PRIMARY_TAG_VALUE
+
+
+def canonical_asset_keys_for_group(
+    asset_graph: BaseAssetGraph, group_name: str
+) -> frozenset[str]:
+    """The user-string keys of a plugin group's canonical (``ctx_primary``)
+    assets — the in-process replacement for state.ts's
+    ``extractCanonicalKeysByPlugin`` (which walked the GraphQL ``assetNodes``)."""
+    return frozenset(
+        asset_key.to_user_string()
+        for asset_key in asset_graph.asset_keys_for_group(group_name)
+        if _is_canonical(asset_graph, asset_key)
+    )
+
+
+def _binding_run_records(
+    instance: dg.DagsterInstance, binding_id: str
+) -> list[RunRecord]:
+    """The binding's most-recent runs (newest-first, capped) projected to
+    ``RunRecord`` — the native-instance replacement for state.ts's per-binding
+    ``runsOrError`` GraphQL query."""
+    # No explicit order_by: get_run_records then sorts by the runs table's
+    # autoincrement id DESC — a strict total order (newest-created first) with no
+    # ties. create_timestamp DESC would tie when runs are created in the same
+    # instant, making "latest" (and the frontier's per-key newest-success pick) flap.
+    records = instance.get_run_records(
+        filters=dg.RunsFilter(tags={PARTITION_TAG_KEY: binding_id}),
+        limit=RUNS_PER_BINDING_LIMIT,
+    )
+    return [
+        RunRecord(
+            asset_keys=tuple(
+                asset_key.to_user_string()
+                for asset_key in (record.dagster_run.asset_selection or ())
+            ),
+            start_time=record.start_time,
+            status=record.dagster_run.status.value,
+        )
+        for record in records
+    ]
+
+
+def _report_binding_sync_state_for_run(
+    context: dg.RunStatusSensorContext,
+    base_platform: BasePlatformClient,
+) -> None:
+    """Recompute and push one binding's digest in response to a run-status
+    transition. Skips runs that are not a canonical binding sync — no partition
+    key, or no ``ctx_primary`` asset in the run's selection (the binding's plugin
+    group is read off that selection)."""
+    binding_id = context.partition_key
+    if binding_id is None:
+        return
+
+    asset_graph = context.repository_def.asset_graph
+    selection = context.dagster_run.asset_selection or frozenset()
+    group_name = next(
+        (
+            asset_graph.get(asset_key).group_name
+            for asset_key in selection
+            if _is_canonical(asset_graph, asset_key)
+        ),
+        None,
+    )
+    if group_name is None:
+        return
+
+    canonical_keys = canonical_asset_keys_for_group(asset_graph, group_name)
+    runs = _binding_run_records(context.instance, binding_id)
+    state = fold_binding_sync_state(canonical_keys, runs)
+    base_platform.report_binding_sync_state(binding_id, state)
+
+
+# Two sensors, one producer: ``@run_status_sensor`` monitors a single status, so
+# SUCCESS (advances the frontier) and FAILURE (surfaces a broken binding) each
+# get a thin wrapper delegating to the shared producer above. STARTED/CANCELED
+# are deferred — a binding's transient "syncing"/"canceled" state is not needed
+# by the freshness/health view.
+@dg.run_status_sensor(
+    name="binding_sync_state_success_sensor",
+    run_status=dg.DagsterRunStatus.SUCCESS,
+    default_status=dg.DefaultSensorStatus.RUNNING,
+    minimum_interval_seconds=30,
+)
+def binding_sync_state_success_sensor(
+    context: dg.RunStatusSensorContext,
+    base_platform: dg.ResourceParam[BasePlatformClient],
+) -> None:
+    _report_binding_sync_state_for_run(context, base_platform)
+
+
+@dg.run_status_sensor(
+    name="binding_sync_state_failure_sensor",
+    run_status=dg.DagsterRunStatus.FAILURE,
+    default_status=dg.DefaultSensorStatus.RUNNING,
+    minimum_interval_seconds=30,
+)
+def binding_sync_state_failure_sensor(
+    context: dg.RunStatusSensorContext,
+    base_platform: dg.ResourceParam[BasePlatformClient],
+) -> None:
+    _report_binding_sync_state_for_run(context, base_platform)
+
+
+@dg.definitions
+def defs() -> dg.Definitions:
+    return dg.Definitions(
+        sensors=[
+            binding_sync_state_success_sensor,
+            binding_sync_state_failure_sensor,
+        ]
+    )

pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "contextbase-core"
+requires-python = ">=3.12,<3.13"
+version = "0.0.0-alpha-1"
+dependencies = [
+    "contextbase-plugin-asana==0.0.0-alpha-1",
+    "contextbase-plugin-chrome-local==0.0.0-alpha-1",
+    "contextbase-plugin-claude-local==0.0.0-alpha-1",
+    "contextbase-plugin-clickup==0.0.0-alpha-1",
+    "contextbase-plugin-codex-local==0.0.0-alpha-1",
+    "contextbase-plugin-github==0.0.0-alpha-1",
+    "contextbase-plugin-gmail==0.0.0-alpha-1",
+    "contextbase-plugin-gong==0.0.0-alpha-1",
+    "contextbase-plugin-google-calendar==0.0.0-alpha-1",
+    "contextbase-plugin-granola==0.0.0-alpha-1",
+    "contextbase-plugin-hubspot==0.0.0-alpha-1",
+    "contextbase-plugin-icloud-tabs-local==0.0.0-alpha-1",
+    "contextbase-plugin-imessage-local==0.0.0-alpha-1",
+    "contextbase-plugin-intercom==0.0.0-alpha-1",
+    "contextbase-plugin-jira==0.0.0-alpha-1",
+    "contextbase-plugin-linear==0.0.0-alpha-1",
+    "contextbase-plugin-microsoft-calendar==0.0.0-alpha-1",
+    "contextbase-plugin-microsoft-mail==0.0.0-alpha-1",
+    "contextbase-plugin-microsoft-planner-premium==0.0.0-alpha-1",
+    "contextbase-plugin-notion==0.0.0-alpha-1",
+    "contextbase-plugin-reminders-local==0.0.0-alpha-1",
+    "contextbase-plugin-salesforce==0.0.0-alpha-1",
+    "contextbase-plugin-slack==0.0.0-alpha-1",
+    "contextbase-plugin-whatsapp-local==0.0.0-alpha-1",
+    "contextbase-plugin-workflowy==0.0.0-alpha-1",
+    "contextbase-shared-plugins==0.0.0-alpha-1",
+    "dagster==1.12.14",
+    "httpx>=0.28.1",
+    "pydantic-settings>=2.11.0",
+]
+
+[dependency-groups]
+dev = [
+    "dagster-webserver",
+    "dagster-dg-cli",
+    "pytest>=8.4.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/core"]
+force-include = { "pyproject.toml" = "pyproject.toml" }
+
+[tool.dg]
+directory_type = "project"
+
+[tool.dg.project]
+root_module = "core"
+
+[tool.uv.sources]
+contextbase-plugin-asana = { workspace = true }
+contextbase-plugin-chrome-local = { workspace = true }
+contextbase-plugin-claude-local = { workspace = true }
+contextbase-plugin-clickup = { workspace = true }
+contextbase-plugin-codex-local = { workspace = true }
+contextbase-plugin-github = { workspace = true }
+contextbase-plugin-gmail = { workspace = true }
+contextbase-plugin-gong = { workspace = true }
+contextbase-plugin-google-calendar = { workspace = true }
+contextbase-plugin-granola = { workspace = true }
+contextbase-plugin-hubspot = { workspace = true }
+contextbase-plugin-icloud-tabs-local = { workspace = true }
+contextbase-plugin-imessage-local = { workspace = true }
+contextbase-plugin-intercom = { workspace = true }
+contextbase-plugin-jira = { workspace = true }
+contextbase-plugin-linear = { workspace = true }
+contextbase-plugin-microsoft-calendar = { workspace = true }
+contextbase-plugin-microsoft-mail = { workspace = true }
+contextbase-plugin-microsoft-planner-premium = { workspace = true }
+contextbase-plugin-notion = { workspace = true }
+contextbase-plugin-reminders-local = { workspace = true }
+contextbase-plugin-salesforce = { workspace = true }
+contextbase-plugin-slack = { workspace = true }
+contextbase-plugin-whatsapp-local = { workspace = true }
+contextbase-plugin-workflowy = { workspace = true }
+contextbase-shared-plugins = { workspace = true }