airbyte-internal-ops 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

{airbyte_internal_ops-0.3.1.dist-info → airbyte_internal_ops-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.3.1
+Version: 0.4.0
 Summary: MCP and API interfaces that let the agents do the admin work
 Author-email: Aaron Steers <aj@airbyte.io>
 Keywords: admin,airbyte,api,mcp

{airbyte_internal_ops-0.3.1.dist-info → airbyte_internal_ops-0.4.0.dist-info}/RECORD

@@ -379,18 +379,18 @@ airbyte_ops_mcp/mcp/gcp_logs.py,sha256=IPtq4098_LN1Cgeba4jATO1iYFFFpL2-aRO0pGcOd
 airbyte_ops_mcp/mcp/github.py,sha256=h3M3VJrq09y_F9ueQVCq3bUbVBNFuTNKprHtGU_ttio,8045
 airbyte_ops_mcp/mcp/github_repo_ops.py,sha256=PiERpt8abo20Gz4CfXhrDNlVM4o4FOt5sweZJND2a0s,5314
 airbyte_ops_mcp/mcp/metadata.py,sha256=fwGW97WknR5lfKcQnFtK6dU87aA6TmLj1NkKyqDAV9g,270
-airbyte_ops_mcp/mcp/prerelease.py,sha256=nc6VU03ADVHWM3OjGKxbS5XqY4VoyRyrZNU_fyAtaOI,10465
-airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=DPzyHCT3yxj2kjkucefoVpsR71vscuJQ8tGgLs_lhv0,32068
+airbyte_ops_mcp/mcp/prerelease.py,sha256=GI4p1rGDCLZ6QbEG57oD_M3_buIHwq9B0In6fbj7Ptk,11883
+airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=VsiBBnVbOjc8lBb2Xr1lmcH3wu7QHQfjd4lORarEE1s,42700
 airbyte_ops_mcp/mcp/prompts.py,sha256=mJld9mdPECXYZffWXGSvNs4Xevx3rxqUGNlzGKVC2_s,1599
 airbyte_ops_mcp/mcp/registry.py,sha256=PW-VYUj42qx2pQ_apUkVaoUFq7VgB9zEU7-aGrkSCCw,290
-airbyte_ops_mcp/mcp/regression_tests.py,sha256=S1h-5S5gcZA4WEtIZyAQ836hd04tjSRRqMiYMx0S93g,16079
+airbyte_ops_mcp/mcp/regression_tests.py,sha256=VpXS36Ox2qPxtxnDhVoNfr83UfppWx8rMgCoDiKWzWg,16727
 airbyte_ops_mcp/mcp/server.py,sha256=lKAXxt4u4bz7dsKvAYFFHziMbun2pOnxYmrMtRxsZvM,5317
 airbyte_ops_mcp/mcp/server_info.py,sha256=Yi4B1auW64QZGBDas5mro_vwTjvrP785TFNSBP7GhRg,2361
 airbyte_ops_mcp/prod_db_access/__init__.py,sha256=5pxouMPY1beyWlB0UwPnbaLTKTHqU6X82rbbgKY2vYU,1069
 airbyte_ops_mcp/prod_db_access/db_engine.py,sha256=VUqEWZtharJUR-Cri_pMwtGh1C4Neu4s195mbEXlm-w,9190
 airbyte_ops_mcp/prod_db_access/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-airbyte_ops_mcp/prod_db_access/queries.py,sha256=TNxTY5Hf3ImHBX0_e_20-VbF3yzYm2mX3ykWzQXgpno,17754
-airbyte_ops_mcp/prod_db_access/sql.py,sha256=xB7SJGnBSlY-ZB7ku_9QfvNIEldGEmCn-jJcAdes_LY,30407
+airbyte_ops_mcp/prod_db_access/queries.py,sha256=pyW5GxDZ5ibwXawxyI_IR7VFcmoX7pZyZ2jdADqhJRY,20276
+airbyte_ops_mcp/prod_db_access/sql.py,sha256=lzFOYfkb-rFTaZ6vrAK9G8Ym4KTUdhPMBzK44NSRzcg,35362
 airbyte_ops_mcp/registry/__init__.py,sha256=iEaPlt9GrnlaLbc__98TguNeZG8wuQu7S-_2QkhHcbA,858
 airbyte_ops_mcp/registry/models.py,sha256=B4L4TKr52wo0xs0CqvCBrpowqjShzVnZ5eTr2-EyhNs,2346
 airbyte_ops_mcp/registry/publish.py,sha256=VoPxsM2_0zJ829orzCRN-kjgcJtuBNyXgW4I9J680ro,12717
@@ -400,7 +400,7 @@ airbyte_ops_mcp/regression_tests/ci_output.py,sha256=rrvCVKKShc1iVPMuQJDBqSbsiAH
 airbyte_ops_mcp/regression_tests/config.py,sha256=dwWeY0tatdbwl9BqbhZ7EljoZDCtKmGO5fvOAIxeXmA,5873
 airbyte_ops_mcp/regression_tests/connection_fetcher.py,sha256=5wIiA0VvCFNEc-fr6Po18gZMX3E5fyPOGf2SuVOqv5U,12799
 airbyte_ops_mcp/regression_tests/connection_secret_retriever.py,sha256=FhWNVWq7sON4nwUmVJv8BgXBOqg1YV4b5WuWyCzZ0LU,4695
-airbyte_ops_mcp/regression_tests/connector_runner.py,sha256=bappfBSq8dn3IyVAMS_XuzYEwWus23hkDCHLa2RFysI,9920
+airbyte_ops_mcp/regression_tests/connector_runner.py,sha256=OZzUa2aLh0sHaEARsDePOA-e3qEX4cvh3Jhnvi8S1rY,10130
 airbyte_ops_mcp/regression_tests/evaluation_modes.py,sha256=lAL6pEDmy_XCC7_m4_NXjt_f6Z8CXeAhMkc0FU8bm_M,1364
 airbyte_ops_mcp/regression_tests/http_metrics.py,sha256=oTD7f2MnQOvx4plOxHop2bInQ0-whvuToSsrC7TIM-M,12469
 airbyte_ops_mcp/regression_tests/models.py,sha256=brtAT9oO1TwjFcP91dFcu0XcUNqQb-jf7di1zkoVEuo,8782
@@ -414,7 +414,7 @@ airbyte_ops_mcp/regression_tests/regression/comparators.py,sha256=MJkLZEKHivgrG0
 airbyte_ops_mcp/regression_tests/validation/__init__.py,sha256=MBEwGOoNuqT4_oCahtoK62OKWIjUCfWa7vZTxNj_0Ek,1532
 airbyte_ops_mcp/regression_tests/validation/catalog_validators.py,sha256=jqqVAMOk0mtdPgwu4d0hA0ZEjtsNh5gapvGydRv3_qk,12553
 airbyte_ops_mcp/regression_tests/validation/record_validators.py,sha256=RjauAhKWNwxMBTu0eNS2hMFNQVs5CLbQU51kp6FOVDk,7432
-airbyte_internal_ops-0.3.1.dist-info/METADATA,sha256=kx1iQ0YE42LjpsFpjJD7SECaYMHEjo36VjvSVf3BwHk,5679
-airbyte_internal_ops-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-airbyte_internal_ops-0.3.1.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
-airbyte_internal_ops-0.3.1.dist-info/RECORD,,
+airbyte_internal_ops-0.4.0.dist-info/METADATA,sha256=K9rJIUSobD2QWdHccHpKZooawgipH8ZozDqTl0FrG-8,5679
+airbyte_internal_ops-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_internal_ops-0.4.0.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
+airbyte_internal_ops-0.4.0.dist-info/RECORD,,

airbyte_ops_mcp/mcp/prerelease.py

@@ -2,12 +2,15 @@
 """MCP tools for triggering connector pre-release workflows.
 
 This module provides MCP tools for triggering the publish-connectors-prerelease
-workflow in the airbytehq/airbyte repository via GitHub's workflow dispatch API.
+workflow in the airbytehq/airbyte repository (for OSS connectors) or the
+publish_enterprise_connectors workflow in airbytehq/airbyte-enterprise
+(for enterprise connectors) via GitHub's workflow dispatch API.
 """
 
 from __future__ import annotations
 
 import base64
+from enum import StrEnum
 from typing import Annotated, Literal
 
 import requests
@@ -18,12 +21,25 @@ from pydantic import BaseModel, Field
 from airbyte_ops_mcp.github_actions import GITHUB_API_BASE, resolve_github_token
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
+
+class ConnectorRepo(StrEnum):
+    """Repository where connector code is located."""
+
+    AIRBYTE = "airbyte"
+    AIRBYTE_ENTERPRISE = "airbyte-enterprise"
+
+
 DEFAULT_REPO_OWNER = "airbytehq"
-DEFAULT_REPO_NAME = "airbyte"
+DEFAULT_REPO_NAME = ConnectorRepo.AIRBYTE
 DEFAULT_BRANCH = "master"
 PRERELEASE_WORKFLOW_FILE = "publish-connectors-prerelease-command.yml"
 CONNECTOR_PATH_PREFIX = "airbyte-integrations/connectors"
 
+# Enterprise repository constants
+ENTERPRISE_REPO_NAME = ConnectorRepo.AIRBYTE_ENTERPRISE
+ENTERPRISE_DEFAULT_BRANCH = "main"
+ENTERPRISE_PRERELEASE_WORKFLOW_FILE = "publish_enterprise_connectors.yml"
+
 # Token env vars for prerelease publishing (in order of preference)
 PRERELEASE_TOKEN_ENV_VARS = [
     "GITHUB_CONNECTOR_PUBLISHING_PAT",
@@ -238,6 +254,14 @@ def publish_connector_to_airbyte_registry(
         int,
         Field(description="The pull request number containing the connector changes"),
     ],
+    repo: Annotated[
+        ConnectorRepo,
+        Field(
+            default=ConnectorRepo.AIRBYTE,
+            description="Repository where the connector PR is located. "
+            "Use 'airbyte' for OSS connectors (default) or 'airbyte-enterprise' for enterprise connectors.",
+        ),
+    ],
     prerelease: Annotated[
         Literal[True],
         Field(
@@ -249,8 +273,10 @@ def publish_connector_to_airbyte_registry(
     """Publish a connector to the Airbyte registry.
 
     Currently only supports pre-release publishing. This tool triggers the
-    publish-connectors-prerelease workflow in the airbytehq/airbyte repository,
-    which publishes a pre-release version of the specified connector from the PR branch.
+    publish-connectors-prerelease workflow in the airbytehq/airbyte repository
+    (for OSS connectors) or the publish_enterprise_connectors workflow in
+    airbytehq/airbyte-enterprise (for enterprise connectors), which publishes
+    a pre-release version of the specified connector from the PR branch.
 
     Pre-release versions are tagged with the format: {version}-preview.{7-char-git-sha}
     These versions are available for version pinning via the scoped_configuration API.
@@ -267,17 +293,27 @@ def publish_connector_to_airbyte_registry(
     # Guard: Check for required token
     token = resolve_github_token(PRERELEASE_TOKEN_ENV_VARS)
 
+    # Determine repo-specific settings
+    is_enterprise = repo == ConnectorRepo.AIRBYTE_ENTERPRISE
+    target_repo_name = ENTERPRISE_REPO_NAME if is_enterprise else DEFAULT_REPO_NAME
+    target_branch = ENTERPRISE_DEFAULT_BRANCH if is_enterprise else DEFAULT_BRANCH
+    target_workflow = (
+        ENTERPRISE_PRERELEASE_WORKFLOW_FILE
+        if is_enterprise
+        else PRERELEASE_WORKFLOW_FILE
+    )
+
     # Get the PR's head SHA for computing the docker image tag
     # Note: We no longer pass gitref to the workflow - it derives the ref from PR number
     head_info = _get_pr_head_info(
-        DEFAULT_REPO_OWNER, DEFAULT_REPO_NAME, pr_number, token
+        DEFAULT_REPO_OWNER, target_repo_name, pr_number, token
     )
 
     # Prepare workflow inputs
     # The workflow uses refs/pull/{pr}/head directly - no gitref needed
     # Note: The workflow auto-detects modified connectors from the PR
     workflow_inputs = {
-        "repo": f"{DEFAULT_REPO_OWNER}/{DEFAULT_REPO_NAME}",
+        "repo": f"{DEFAULT_REPO_OWNER}/{target_repo_name}",
         "pr": str(pr_number),
     }
 
@@ -285,9 +321,9 @@ def publish_connector_to_airbyte_registry(
     # The workflow will checkout the PR branch via inputs.gitref
     workflow_url = _trigger_workflow_dispatch(
         owner=DEFAULT_REPO_OWNER,
-        repo=DEFAULT_REPO_NAME,
-        workflow_file=PRERELEASE_WORKFLOW_FILE,
-        ref=DEFAULT_BRANCH,
+        repo=target_repo_name,
+        workflow_file=target_workflow,
+        ref=target_branch,
         inputs=workflow_inputs,
         token=token,
     )
@@ -297,7 +333,7 @@ def publish_connector_to_airbyte_registry(
     docker_image_tag: str | None = None
     metadata = _get_connector_metadata(
         DEFAULT_REPO_OWNER,
-        DEFAULT_REPO_NAME,
+        target_repo_name,
         connector_name,
         head_info.sha,
         token,
@@ -311,9 +347,10 @@ def publish_connector_to_airbyte_registry(
                 base_version, head_info.sha
             )
 
+    repo_info = f" from {repo}" if is_enterprise else ""
     return PrereleaseWorkflowResult(
         success=True,
-        message=f"Successfully triggered pre-release workflow for {connector_name} from PR #{pr_number}",
+        message=f"Successfully triggered pre-release workflow for {connector_name}{repo_info} from PR #{pr_number}",
         workflow_url=workflow_url,
         connector_name=connector_name,
         pr_number=pr_number,

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -7,7 +7,7 @@ airbyte_ops_mcp.prod_db_access.queries for use by AI agents.
 
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import StrEnum
 from typing import Annotated, Any
 
@@ -24,9 +24,11 @@ from airbyte_ops_mcp.prod_db_access.queries import (
     query_connections_by_destination_connector,
     query_connector_versions,
     query_dataplanes_list,
+    query_destination_connection_stats,
     query_failed_sync_attempts_for_connector,
     query_new_connector_releases,
     query_recent_syncs_for_connector,
+    query_source_connection_stats,
     query_syncs_for_version_pinned_connector,
     query_workspace_info,
     query_workspaces_by_email_domain,
@@ -90,6 +92,94 @@ class WorkspacesByEmailDomainResult(BaseModel):
     )
 
 
+class LatestAttemptBreakdown(BaseModel):
+    """Breakdown of connections by latest attempt status."""
+
+    succeeded: int = Field(
+        default=0, description="Connections where latest attempt succeeded"
+    )
+    failed: int = Field(
+        default=0, description="Connections where latest attempt failed"
+    )
+    cancelled: int = Field(
+        default=0, description="Connections where latest attempt was cancelled"
+    )
+    running: int = Field(
+        default=0, description="Connections where latest attempt is still running"
+    )
+    unknown: int = Field(
+        default=0,
+        description="Connections with no recent attempts in the lookback window",
+    )
+
+
+class VersionPinStats(BaseModel):
+    """Stats for connections pinned to a specific version."""
+
+    pinned_version_id: str | None = Field(
+        description="The connector version UUID (None for unpinned connections)"
+    )
+    docker_image_tag: str | None = Field(
+        default=None, description="The docker image tag for this version"
+    )
+    total_connections: int = Field(description="Total number of connections")
+    enabled_connections: int = Field(
+        description="Number of enabled (active status) connections"
+    )
+    active_connections: int = Field(
+        description="Number of connections with recent sync activity"
+    )
+    latest_attempt: LatestAttemptBreakdown = Field(
+        description="Breakdown by latest attempt status"
+    )
+
+
+class ConnectorConnectionStats(BaseModel):
+    """Aggregate connection stats for a connector."""
+
+    connector_definition_id: str = Field(description="The connector definition UUID")
+    connector_type: str = Field(description="'source' or 'destination'")
+    canonical_name: str | None = Field(
+        default=None, description="The canonical connector name if resolved"
+    )
+    total_connections: int = Field(
+        description="Total number of non-deprecated connections"
+    )
+    enabled_connections: int = Field(
+        description="Number of enabled (active status) connections"
+    )
+    active_connections: int = Field(
+        description="Number of connections with recent sync activity"
+    )
+    pinned_connections: int = Field(
+        description="Number of connections with explicit version pins"
+    )
+    unpinned_connections: int = Field(
+        description="Number of connections on default version"
+    )
+    latest_attempt: LatestAttemptBreakdown = Field(
+        description="Overall breakdown by latest attempt status"
+    )
+    by_version: list[VersionPinStats] = Field(
+        description="Stats broken down by pinned version"
+    )
+
+
+class ConnectorConnectionStatsResponse(BaseModel):
+    """Response containing connection stats for multiple connectors."""
+
+    sources: list[ConnectorConnectionStats] = Field(
+        default_factory=list, description="Stats for source connectors"
+    )
+    destinations: list[ConnectorConnectionStats] = Field(
+        default_factory=list, description="Stats for destination connectors"
+    )
+    active_within_days: int = Field(
+        description="Lookback window used for 'active' connections"
+    )
+    generated_at: datetime = Field(description="When this response was generated")
+
+
 # Cloud registry URL for resolving canonical names
 CLOUD_REGISTRY_URL = (
     "https://connectors.airbyte.com/files/registries/v0/cloud_registry.json"
@@ -851,6 +941,213 @@ def query_prod_workspaces_by_email_domain(
     )
 
 
+def _build_connector_stats(
+    connector_definition_id: str,
+    connector_type: str,
+    canonical_name: str | None,
+    rows: list[dict[str, Any]],
+    version_tags: dict[str, str | None],
+) -> ConnectorConnectionStats:
+    """Build ConnectorConnectionStats from query result rows."""
+    # Aggregate totals across all version groups
+    total_connections = 0
+    enabled_connections = 0
+    active_connections = 0
+    pinned_connections = 0
+    unpinned_connections = 0
+    total_succeeded = 0
+    total_failed = 0
+    total_cancelled = 0
+    total_running = 0
+    total_unknown = 0
+
+    by_version: list[VersionPinStats] = []
+
+    for row in rows:
+        version_id = row.get("pinned_version_id")
+        row_total = int(row.get("total_connections", 0))
+        row_enabled = int(row.get("enabled_connections", 0))
+        row_active = int(row.get("active_connections", 0))
+        row_pinned = int(row.get("pinned_connections", 0))
+        row_unpinned = int(row.get("unpinned_connections", 0))
+        row_succeeded = int(row.get("succeeded_connections", 0))
+        row_failed = int(row.get("failed_connections", 0))
+        row_cancelled = int(row.get("cancelled_connections", 0))
+        row_running = int(row.get("running_connections", 0))
+        row_unknown = int(row.get("unknown_connections", 0))
+
+        total_connections += row_total
+        enabled_connections += row_enabled
+        active_connections += row_active
+        pinned_connections += row_pinned
+        unpinned_connections += row_unpinned
+        total_succeeded += row_succeeded
+        total_failed += row_failed
+        total_cancelled += row_cancelled
+        total_running += row_running
+        total_unknown += row_unknown
+
+        by_version.append(
+            VersionPinStats(
+                pinned_version_id=str(version_id) if version_id else None,
+                docker_image_tag=version_tags.get(str(version_id))
+                if version_id
+                else None,
+                total_connections=row_total,
+                enabled_connections=row_enabled,
+                active_connections=row_active,
+                latest_attempt=LatestAttemptBreakdown(
+                    succeeded=row_succeeded,
+                    failed=row_failed,
+                    cancelled=row_cancelled,
+                    running=row_running,
+                    unknown=row_unknown,
+                ),
+            )
+        )
+
+    return ConnectorConnectionStats(
+        connector_definition_id=connector_definition_id,
+        connector_type=connector_type,
+        canonical_name=canonical_name,
+        total_connections=total_connections,
+        enabled_connections=enabled_connections,
+        active_connections=active_connections,
+        pinned_connections=pinned_connections,
+        unpinned_connections=unpinned_connections,
+        latest_attempt=LatestAttemptBreakdown(
+            succeeded=total_succeeded,
+            failed=total_failed,
+            cancelled=total_cancelled,
+            running=total_running,
+            unknown=total_unknown,
+        ),
+        by_version=by_version,
+    )
+
+
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+    open_world=True,
+)
+def query_prod_connector_connection_stats(
+    source_definition_ids: Annotated[
+        list[str] | None,
+        Field(
+            description=(
+                "List of source connector definition IDs (UUIDs) to get stats for. "
+                "Example: ['afa734e4-3571-11ec-991a-1e0031268139']"
+            ),
+            default=None,
+        ),
+    ] = None,
+    destination_definition_ids: Annotated[
+        list[str] | None,
+        Field(
+            description=(
+                "List of destination connector definition IDs (UUIDs) to get stats for. "
+                "Example: ['94bd199c-2ff0-4aa2-b98e-17f0acb72610']"
+            ),
+            default=None,
+        ),
+    ] = None,
+    active_within_days: Annotated[
+        int,
+        Field(
+            description=(
+                "Number of days to look back for 'active' connections (default: 7). "
+                "Connections with sync activity within this window are counted as active."
+            ),
+            default=7,
+        ),
+    ] = 7,
+) -> ConnectorConnectionStatsResponse:
+    """Get aggregate connection stats for multiple connectors.
+
+    Returns counts of connections grouped by pinned version for each connector,
+    including:
+    - Total, enabled, and active connection counts
+    - Pinned vs unpinned breakdown
+    - Latest attempt status breakdown (succeeded, failed, cancelled, running, unknown)
+
+    This tool is designed for release monitoring workflows. It allows you to:
+    1. Query recently released connectors to identify which ones to monitor
+    2. Get aggregate stats showing how many connections are using each version
+    3. See health metrics (pass/fail) broken down by version
+
+    The 'active_within_days' parameter controls the lookback window for:
+    - Counting 'active' connections (those with recent sync activity)
+    - Determining 'latest attempt status' (most recent attempt within the window)
+
+    Connections with no sync activity in the lookback window will have
+    'unknown' status in the latest_attempt breakdown.
+    """
+    # Initialize empty lists if None
+    source_ids = source_definition_ids or []
+    destination_ids = destination_definition_ids or []
+
+    if not source_ids and not destination_ids:
+        raise PyAirbyteInputError(
+            message=(
+                "At least one of source_definition_ids or destination_definition_ids "
+                "must be provided."
+            ),
+        )
+
+    sources: list[ConnectorConnectionStats] = []
+    destinations: list[ConnectorConnectionStats] = []
+
+    # Process source connectors
+    for source_def_id in source_ids:
+        # Get version info for tag lookup
+        versions = query_connector_versions(source_def_id)
+        version_tags = {
+            str(v["version_id"]): v.get("docker_image_tag") for v in versions
+        }
+
+        # Get aggregate stats
+        rows = query_source_connection_stats(source_def_id, days=active_within_days)
+
+        sources.append(
+            _build_connector_stats(
+                connector_definition_id=source_def_id,
+                connector_type="source",
+                canonical_name=None,
+                rows=rows,
+                version_tags=version_tags,
+            )
+        )
+
+    # Process destination connectors
+    for dest_def_id in destination_ids:
+        # Get version info for tag lookup
+        versions = query_connector_versions(dest_def_id)
+        version_tags = {
+            str(v["version_id"]): v.get("docker_image_tag") for v in versions
+        }
+
+        # Get aggregate stats
+        rows = query_destination_connection_stats(dest_def_id, days=active_within_days)
+
+        destinations.append(
+            _build_connector_stats(
+                connector_definition_id=dest_def_id,
+                connector_type="destination",
+                canonical_name=None,
+                rows=rows,
+                version_tags=version_tags,
+            )
+        )
+
+    return ConnectorConnectionStatsResponse(
+        sources=sources,
+        destinations=destinations,
+        active_within_days=active_within_days,
+        generated_at=datetime.now(timezone.utc),
+    )
+
+
 def register_prod_db_query_tools(app: FastMCP) -> None:
     """Register prod DB query tools with the FastMCP app."""
     register_mcp_tools(app, domain=__name__)

airbyte_ops_mcp/mcp/regression_tests.py

@@ -37,6 +37,7 @@ from airbyte_ops_mcp.github_actions import (
     trigger_workflow_dispatch,
 )
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
+from airbyte_ops_mcp.mcp.prerelease import ConnectorRepo
 
 logger = logging.getLogger(__name__)
 
@@ -309,7 +310,13 @@ def run_regression_tests(
     ],
     pr: Annotated[
         int,
-        "PR number from the airbyte monorepo to checkout and build from (e.g., 70847). Required.",
+        "PR number to checkout and build from (e.g., 70847). Required. "
+        "The PR must be from the repository specified by the 'repo' parameter.",
+    ],
+    repo: Annotated[
+        ConnectorRepo,
+        "Repository where the connector PR is located. "
+        "Use 'airbyte' for OSS connectors (default) or 'airbyte-enterprise' for enterprise connectors.",
     ],
     connection_id: Annotated[
         str | None,
@@ -347,6 +354,10 @@ def run_regression_tests(
     This tool triggers the regression test workflow which builds the connector
     from the specified PR and runs tests against it.
 
+    Supports both OSS connectors (from airbytehq/airbyte) and enterprise connectors
+    (from airbytehq/airbyte-enterprise). Use the 'repo' parameter to specify which
+    repository contains the connector PR.
+
     - skip_compare=False (default): Comparison mode - compares the PR version
       against the baseline (control) version.
     - skip_compare=True: Single-version mode - runs tests without comparison.
@@ -390,10 +401,11 @@ def run_regression_tests(
                 workflow_url=None,
             )
 
-    # Build workflow inputs - connector_name and pr are required
+    # Build workflow inputs - connector_name, pr, and repo are required
     workflow_inputs: dict[str, str] = {
         "connector_name": connector_name,
         "pr": str(pr),
+        "repo": repo,
     }
 
     # Add optional inputs
@@ -431,12 +443,13 @@ def run_regression_tests(
 
     view_url = dispatch_result.run_url or dispatch_result.workflow_url
     connection_info = f" for connection {connection_id}" if connection_id else ""
+    repo_info = f" from {repo}" if repo != ConnectorRepo.AIRBYTE else ""
     return RunRegressionTestsResponse(
         run_id=run_id,
         status=TestRunStatus.QUEUED,
         message=(
             f"{mode_description.capitalize()} regression test workflow triggered "
-            f"for {connector_name} (PR #{pr}){connection_info}. View progress at: {view_url}"
+            f"for {connector_name} (PR #{pr}{repo_info}){connection_info}. View progress at: {view_url}"
         ),
         workflow_url=dispatch_result.workflow_url,
         github_run_id=dispatch_result.run_id,

airbyte_ops_mcp/prod_db_access/queries.py

@@ -26,6 +26,7 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
+    SELECT_DESTINATION_CONNECTION_STATS,
     SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
     SELECT_NEW_CONNECTOR_RELEASES,
     SELECT_ORG_WORKSPACES,
@@ -35,6 +36,7 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR,
     SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR,
     SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR,
+    SELECT_SOURCE_CONNECTION_STATS,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
     SELECT_SYNC_RESULTS_FOR_VERSION,
     SELECT_WORKSPACE_INFO,
@@ -497,3 +499,69 @@ def query_workspaces_by_email_domain(
         query_name="SELECT_WORKSPACES_BY_EMAIL_DOMAIN",
         gsm_client=gsm_client,
     )
+
+
+def query_source_connection_stats(
+    connector_definition_id: str,
+    days: int = 7,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query aggregate connection stats for a SOURCE connector.
+
+    Returns counts of connections grouped by pinned version, including:
+    - Total, enabled, and active connection counts
+    - Pinned vs unpinned breakdown
+    - Latest attempt status breakdown (succeeded, failed, cancelled, running, unknown)
+
+    Args:
+        connector_definition_id: Source connector definition UUID
+        days: Number of days to look back for "active" connections (default: 7)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of dicts with aggregate counts grouped by pinned_version_id
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+    return _run_sql_query(
+        SELECT_SOURCE_CONNECTION_STATS,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "cutoff_date": cutoff_date,
+        },
+        query_name="SELECT_SOURCE_CONNECTION_STATS",
+        gsm_client=gsm_client,
+    )
+
+
+def query_destination_connection_stats(
+    connector_definition_id: str,
+    days: int = 7,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query aggregate connection stats for a DESTINATION connector.
+
+    Returns counts of connections grouped by pinned version, including:
+    - Total, enabled, and active connection counts
+    - Pinned vs unpinned breakdown
+    - Latest attempt status breakdown (succeeded, failed, cancelled, running, unknown)
+
+    Args:
+        connector_definition_id: Destination connector definition UUID
+        days: Number of days to look back for "active" connections (default: 7)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of dicts with aggregate counts grouped by pinned_version_id
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+    return _run_sql_query(
+        SELECT_DESTINATION_CONNECTION_STATS,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "cutoff_date": cutoff_date,
+        },
+        query_name="SELECT_DESTINATION_CONNECTION_STATS",
+        gsm_client=gsm_client,
+    )

airbyte_ops_mcp/prod_db_access/sql.py

@@ -826,3 +826,111 @@ SELECT_WORKSPACES_BY_EMAIL_DOMAIN = sqlalchemy.text(
     LIMIT :limit
     """
 )
+
+# =============================================================================
+# Connector Connection Stats Queries (Aggregate Counts)
+# =============================================================================
+
+# Count connections by SOURCE connector with latest attempt status breakdown
+# Groups by pinned version and provides counts of succeeded/failed/other attempts
+# Uses a CTE to get the latest attempt per connection, then aggregates
+SELECT_SOURCE_CONNECTION_STATS = sqlalchemy.text(
+    """
+    WITH latest_attempts AS (
+        SELECT DISTINCT ON (connection.id)
+            connection.id AS connection_id,
+            connection.status AS connection_status,
+            scoped_configuration.value AS pinned_version_id,
+            attempts.status::text AS latest_attempt_status
+        FROM connection
+        JOIN actor
+          ON connection.source_id = actor.id
+         AND actor.actor_definition_id = :connector_definition_id
+         AND actor.tombstone = false
+        JOIN workspace
+          ON actor.workspace_id = workspace.id
+         AND workspace.tombstone = false
+        LEFT JOIN scoped_configuration
+          ON scoped_configuration.scope_id = actor.id
+         AND scoped_configuration.key = 'connector_version'
+         AND scoped_configuration.scope_type = 'actor'
+        LEFT JOIN jobs
+          ON jobs.scope = connection.id::text
+         AND jobs.config_type = 'sync'
+         AND jobs.updated_at >= :cutoff_date
+        LEFT JOIN attempts
+          ON attempts.job_id = jobs.id
+        WHERE
+             connection.status != 'deprecated'
+        ORDER BY
+             connection.id,
+             attempts.ended_at DESC NULLS LAST
+    )
+    SELECT
+        pinned_version_id,
+        COUNT(*) AS total_connections,
+        COUNT(*) FILTER (WHERE connection_status = 'active') AS enabled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NOT NULL) AS active_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NOT NULL) AS pinned_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NULL) AS unpinned_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'succeeded') AS succeeded_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'failed') AS failed_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'cancelled') AS cancelled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'running') AS running_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NULL) AS unknown_connections
+    FROM latest_attempts
+    GROUP BY pinned_version_id
+    ORDER BY total_connections DESC
+    """
+)
+
+# Count connections by DESTINATION connector with latest attempt status breakdown
+SELECT_DESTINATION_CONNECTION_STATS = sqlalchemy.text(
+    """
+    WITH latest_attempts AS (
+        SELECT DISTINCT ON (connection.id)
+            connection.id AS connection_id,
+            connection.status AS connection_status,
+            scoped_configuration.value AS pinned_version_id,
+            attempts.status::text AS latest_attempt_status
+        FROM connection
+        JOIN actor
+          ON connection.destination_id = actor.id
+         AND actor.actor_definition_id = :connector_definition_id
+         AND actor.tombstone = false
+        JOIN workspace
+          ON actor.workspace_id = workspace.id
+         AND workspace.tombstone = false
+        LEFT JOIN scoped_configuration
+          ON scoped_configuration.scope_id = actor.id
+         AND scoped_configuration.key = 'connector_version'
+         AND scoped_configuration.scope_type = 'actor'
+        LEFT JOIN jobs
+          ON jobs.scope = connection.id::text
+         AND jobs.config_type = 'sync'
+         AND jobs.updated_at >= :cutoff_date
+        LEFT JOIN attempts
+          ON attempts.job_id = jobs.id
+        WHERE
+             connection.status != 'deprecated'
+        ORDER BY
+             connection.id,
+             attempts.ended_at DESC NULLS LAST
+    )
+    SELECT
+        pinned_version_id,
+        COUNT(*) AS total_connections,
+        COUNT(*) FILTER (WHERE connection_status = 'active') AS enabled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NOT NULL) AS active_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NOT NULL) AS pinned_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NULL) AS unpinned_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'succeeded') AS succeeded_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'failed') AS failed_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'cancelled') AS cancelled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'running') AS running_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NULL) AS unknown_connections
+    FROM latest_attempts
+    GROUP BY pinned_version_id
+    ORDER BY total_connections DESC
+    """
+)

airbyte_ops_mcp/regression_tests/connector_runner.py

@@ -105,16 +105,19 @@ class ConnectorRunner:
         if self.config is not None:
             config_path = temp_dir / self.CONFIG_FILE
             config_path.write_text(json.dumps(self.config))
+            config_path.chmod(0o666)
             self.logger.debug(f"Wrote config to {config_path}")
 
         if self.configured_catalog is not None:
             catalog_path = temp_dir / self.CATALOG_FILE
             catalog_path.write_text(self.configured_catalog.json())
+            catalog_path.chmod(0o666)
             self.logger.debug(f"Wrote catalog to {catalog_path}")
 
         if self.state is not None:
             state_path = temp_dir / self.STATE_FILE
             state_path.write_text(json.dumps(self.state))
+            state_path.chmod(0o666)
             self.logger.debug(f"Wrote state to {state_path}")
 
     def _build_docker_command(self, temp_dir: Path) -> list[str]:
@@ -135,7 +138,7 @@ class ConnectorRunner:
             "--name",
             container_name,
             "-v",
-            f"{temp_dir}:{self.DATA_DIR}:ro",
+            f"{temp_dir}:{self.DATA_DIR}",
         ]
 
         if self.proxy_url:
@@ -168,9 +171,10 @@ class ConnectorRunner:
 
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
-            # Make temp directory world-readable so non-root container users can access it
-            # Many connector images run as non-root users (e.g., 'airbyte' user)
-            temp_path.chmod(0o755)
+            # Make temp directory world-writable so non-root container users can read/write
+            # Many connector images run as non-root users (e.g., 'airbyte' user) with
+            # different UIDs than the host user, so they need write access for config migration
+            temp_path.chmod(0o777)
             self._prepare_data_directory(temp_path)
 
             docker_cmd = self._build_docker_command(temp_path)