airbyte-internal-ops 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

{airbyte_internal_ops-0.2.1.dist-info → airbyte_internal_ops-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -121,7 +121,23 @@ Some tools (like `list_org_connections_by_source_type_db`) require access to the
    gcloud auth application-default login
    ```
 
-2. Start Cloud SQL Proxy:
+2. Start Cloud SQL Proxy using one of the following methods:
+
+   **Option A: Using the CLI (Recommended)**
+   
+   Pre-install the CLI tool:
+   ```bash
+   uv tool install airbyte-internal-ops
+   airbyte-ops cloud db start-proxy --port=15432
+   ```
+   
+   Or use as a single-step command:
+   ```bash
+   uvx --from=airbyte-internal-ops airbyte-ops cloud db start-proxy --port=15432
+   ```
+
+   **Option B: Manual startup**
+   
    ```bash
    cloud-sql-proxy prod-ab-cloud-proj:us-west3:prod-pgsql-replica --port=15432
    ```

{airbyte_internal_ops-0.2.1.dist-info → airbyte_internal_ops-0.2.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 airbyte_ops_mcp/__init__.py,sha256=tuzdlMkfnWBnsri5KGHM2M_xuNnzFk2u_aR79mmN7Yg,772
 airbyte_ops_mcp/_annotations.py,sha256=MO-SBDnbykxxHDESG7d8rviZZ4WlZgJKv0a8eBqcEzQ,1757
-airbyte_ops_mcp/constants.py,sha256=THmvIjU3pb7kpNjn7TpRWD86gtDLmtlQwYuFnaQp_rg,3095
+airbyte_ops_mcp/constants.py,sha256=GeZ2_WWluMSrGkyqGvqUVFCy-5PD-lyzZbQ7eO-vyUo,5192
 airbyte_ops_mcp/gcp_auth.py,sha256=5k-k145ZoYhHLjyDES8nrA8f8BBihRI0ykrdD1IcfOs,3599
 airbyte_ops_mcp/github_actions.py,sha256=hcwwew98r0yetWsM7Qmdar3ATLBJQGIn3fJfJ_n59So,8599
 airbyte_ops_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -375,18 +375,18 @@ airbyte_ops_mcp/mcp/connector_qa.py,sha256=aImpqdnqBPDrz10BS0owsV4kuIU2XdalzgbaG
 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=LHLaSd8q0l7boAsVqTXOjFGDxAGsPZdtL3kj5_IOTEE,8852
-airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=_eNMFM1CBQ4OM_daf2iq-L7lvlytqbI_6v48m5vJdSQ,15632
+airbyte_ops_mcp/mcp/prerelease.py,sha256=6G4zMo0KeCIYJPEIryHKHoZUiBHQMagPJU-uw-IzK94,8939
+airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=FfGoq3aEj6ZUT4ysBIs1w7LzzwBeRXTaRvPGEx62RzI,25474
 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=b-EBYPudZ3e0dTCKP4XduHTwe-eOTxsvD5WguMlUvtQ,17653
+airbyte_ops_mcp/mcp/regression_tests.py,sha256=S1h-5S5gcZA4WEtIZyAQ836hd04tjSRRqMiYMx0S93g,16079
 airbyte_ops_mcp/mcp/server.py,sha256=wHRjJU0oJmwvQ0JJma_aIQlI83EPBckzmxwtI-OE_XU,5219
 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=txeqRPbovgqbk7lu8ttiZXgA77abFzzeO3hql2o8c44,11228
-airbyte_ops_mcp/prod_db_access/sql.py,sha256=P6UbIHafg3ibs901DPlJxLilxsc-RrCPvnyzSwP-fMw,16300
+airbyte_ops_mcp/prod_db_access/queries.py,sha256=BBPAQEfcing4G0Q9PEmI8C_9kN26sZc65ZGXd9WuFSw,14257
+airbyte_ops_mcp/prod_db_access/sql.py,sha256=hTbPY4r_rrtJ34B5eVpwyuBMLotyuP--UTv0vl3ZwBw,19432
 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
@@ -410,7 +410,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.2.1.dist-info/METADATA,sha256=c4vegfJA-2IWLkwRY_uVHjjUR79hMLfi8ad-RQrn4Pw,5282
-airbyte_internal_ops-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-airbyte_internal_ops-0.2.1.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
-airbyte_internal_ops-0.2.1.dist-info/RECORD,,
+airbyte_internal_ops-0.2.2.dist-info/METADATA,sha256=1ah9ZGR3rZ1676mhAJzJvrbfqOQsV_fuedRitpJG9h8,5679
+airbyte_internal_ops-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_internal_ops-0.2.2.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
+airbyte_internal_ops-0.2.2.dist-info/RECORD,,

airbyte_ops_mcp/constants.py

@@ -3,7 +3,9 @@
 
 from __future__ import annotations
 
-from enum import Enum
+from enum import Enum, StrEnum
+
+from airbyte.exceptions import PyAirbyteInputError
 
 MCP_SERVER_NAME = "airbyte-internal-ops"
 """The name of the MCP server."""
@@ -59,6 +61,64 @@ CLOUD_REGISTRY_URL = (
 )
 """URL for the Airbyte Cloud connector registry."""
 
+# =============================================================================
+# Organization ID Aliases
+# =============================================================================
+
+
+class OrganizationAliasEnum(StrEnum):
+    """Organization ID aliases that can be used in place of UUIDs.
+
+    Each member's name is the alias (e.g., "@airbyte-internal") and its value
+    is the actual organization UUID. Use `OrganizationAliasEnum.resolve()` to
+    resolve aliases to actual IDs.
+    """
+
+    AIRBYTE_INTERNAL = "664c690e-5263-49ba-b01f-4a6759b3330a"
+    """The Airbyte internal organization for testing and internal operations.
+
+    Alias: @airbyte-internal
+    """
+
+    @classmethod
+    def resolve(cls, org_id: str | None) -> str | None:
+        """Resolve an organization ID alias to its actual UUID.
+
+        Accepts either an alias string (e.g., "@airbyte-internal") or an
+        OrganizationAliasEnum enum member, and returns the actual UUID.
+
+        Returns:
+            The resolved organization ID (UUID), or None if input is None.
+            If the input doesn't start with "@", it is returned unchanged.
+
+        Raises:
+            PyAirbyteInputError: If the input starts with "@" but is not a recognized alias.
+        """
+        if org_id is None:
+            return None
+
+        # Handle OrganizationAliasEnum enum members directly
+        if isinstance(org_id, cls):
+            return org_id.value
+
+        # If it doesn't look like an alias, return as-is (assume it's a UUID)
+        if not org_id.startswith("@"):
+            return org_id
+
+        # Handle alias strings or raise an error if invalid
+        alias_mapping = {
+            "@airbyte-internal": cls.AIRBYTE_INTERNAL.value,
+        }
+        if org_id not in alias_mapping:
+            raise PyAirbyteInputError(
+                message=f"Unknown organization alias: {org_id}",
+                context={
+                    "valid_aliases": list(alias_mapping.keys()),
+                },
+            )
+        return alias_mapping[org_id]
+
+
 CONNECTION_RETRIEVER_PG_CONNECTION_DETAILS_SECRET_ID = (
     "projects/587336813068/secrets/CONNECTION_RETRIEVER_PG_CONNECTION_DETAILS"
 )

airbyte_ops_mcp/mcp/prerelease.py

@@ -228,17 +228,17 @@ def publish_connector_to_airbyte_registry(
     # Guard: Check for required token
     token = resolve_github_token(PRERELEASE_TOKEN_ENV_VARS)
 
-    # Get the PR's head ref and SHA
+    # 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
     )
 
     # Prepare workflow inputs
-    # The workflow expects these inputs from slash-command-dispatch
+    # 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}",
-        "gitref": head_info.ref,
         "pr": str(pr_number),
     }
 

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -7,28 +7,78 @@ airbyte_ops_mcp.prod_db_access.queries for use by AI agents.
 
 from __future__ import annotations
 
+from datetime import datetime
 from typing import Annotated, Any
 
 import requests
 from airbyte.exceptions import PyAirbyteInputError
 from fastmcp import FastMCP
-from pydantic import Field
+from pydantic import BaseModel, Field
 
+from airbyte_ops_mcp.constants import OrganizationAliasEnum
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 from airbyte_ops_mcp.prod_db_access.queries import (
     query_actors_pinned_to_version,
     query_connections_by_connector,
+    query_connections_by_destination_connector,
     query_connector_versions,
     query_dataplanes_list,
     query_failed_sync_attempts_for_connector,
     query_new_connector_releases,
     query_sync_results_for_version,
     query_workspace_info,
+    query_workspaces_by_email_domain,
 )
 
 # Cloud UI base URL for building connection URLs
 CLOUD_UI_BASE_URL = "https://cloud.airbyte.com"
 
+
+# =============================================================================
+# Pydantic Models for MCP Tool Responses
+# =============================================================================
+
+
+class WorkspaceInfo(BaseModel):
+    """Information about a workspace found by email domain search."""
+
+    organization_id: str = Field(description="The organization UUID")
+    workspace_id: str = Field(description="The workspace UUID")
+    workspace_name: str = Field(description="The name of the workspace")
+    slug: str | None = Field(
+        default=None, description="The workspace slug (URL-friendly identifier)"
+    )
+    email: str | None = Field(
+        default=None, description="The email address associated with the workspace"
+    )
+    dataplane_group_id: str | None = Field(
+        default=None, description="The dataplane group UUID (region)"
+    )
+    dataplane_name: str | None = Field(
+        default=None, description="The name of the dataplane (e.g., 'US', 'EU')"
+    )
+    created_at: datetime | None = Field(
+        default=None, description="When the workspace was created"
+    )
+
+
+class WorkspacesByEmailDomainResult(BaseModel):
+    """Result of looking up workspaces by email domain."""
+
+    email_domain: str = Field(
+        description="The email domain that was searched for (e.g., 'motherduck.com')"
+    )
+    total_workspaces_found: int = Field(
+        description="Total number of workspaces matching the email domain"
+    )
+    unique_organization_ids: list[str] = Field(
+        description="List of unique organization IDs found"
+    )
+    workspaces: list[WorkspaceInfo] = Field(
+        description="List of workspaces matching the email domain"
+    )
+
+
 # Cloud registry URL for resolving canonical names
 CLOUD_REGISTRY_URL = (
     "https://connectors.airbyte.com/files/registries/v0/cloud_registry.json"
@@ -36,13 +86,18 @@ CLOUD_REGISTRY_URL = (
 
 
 def _resolve_canonical_name_to_definition_id(canonical_name: str) -> str:
-    """Resolve a canonical source name to a definition ID.
+    """Resolve a canonical connector name to a definition ID.
+
+    Auto-detects whether the connector is a source or destination based on the
+    canonical name prefix ("source-" or "destination-"). If no prefix is present,
+    searches both sources and destinations.
 
     Args:
-        canonical_name: Canonical source name (e.g., 'source-youtube-analytics').
+        canonical_name: Canonical connector name (e.g., 'source-youtube-analytics',
+            'destination-duckdb', 'YouTube Analytics', 'DuckDB').
 
     Returns:
-        The source definition ID (UUID).
+        The connector definition ID (UUID).
 
     Raises:
         PyAirbyteInputError: If the canonical name cannot be resolved.
@@ -56,31 +111,65 @@ def _resolve_canonical_name_to_definition_id(canonical_name: str) -> str:
         )
 
     data = response.json()
-    sources = data.get("sources", [])
-
-    # Normalize the canonical name for matching
     normalized_input = canonical_name.lower().strip()
 
-    # Try exact match on name field
-    for source in sources:
-        source_name = source.get("name", "").lower()
-        # The registry returns names like "YouTube Analytics"
-        # So we need to handle both formats
-        if source_name == normalized_input:
-            return source["sourceDefinitionId"]
-
-        # Also try matching against a slugified version
-        # e.g., "YouTube Analytics" -> "youtube-analytics"
-        slugified = source_name.replace(" ", "-")
-        if slugified == normalized_input or f"source-{slugified}" == normalized_input:
-            return source["sourceDefinitionId"]
+    # Determine which registries to search based on prefix
+    is_source = normalized_input.startswith("source-")
+    is_destination = normalized_input.startswith("destination-")
+
+    # Search sources if it looks like a source or has no prefix
+    if is_source or not is_destination:
+        sources = data.get("sources", [])
+        for source in sources:
+            source_name = source.get("name", "").lower()
+            if source_name == normalized_input:
+                return source["sourceDefinitionId"]
+            slugified = source_name.replace(" ", "-")
+            if (
+                slugified == normalized_input
+                or f"source-{slugified}" == normalized_input
+            ):
+                return source["sourceDefinitionId"]
+
+    # Search destinations if it looks like a destination or has no prefix
+    if is_destination or not is_source:
+        destinations = data.get("destinations", [])
+        for destination in destinations:
+            destination_name = destination.get("name", "").lower()
+            if destination_name == normalized_input:
+                return destination["destinationDefinitionId"]
+            slugified = destination_name.replace(" ", "-")
+            if (
+                slugified == normalized_input
+                or f"destination-{slugified}" == normalized_input
+            ):
+                return destination["destinationDefinitionId"]
+
+    # Build appropriate error message based on what was searched
+    if is_source:
+        connector_type = "source"
+        hint = (
+            "Use the exact canonical name (e.g., 'source-youtube-analytics') "
+            "or display name (e.g., 'YouTube Analytics')."
+        )
+    elif is_destination:
+        connector_type = "destination"
+        hint = (
+            "Use the exact canonical name (e.g., 'destination-duckdb') "
+            "or display name (e.g., 'DuckDB')."
+        )
+    else:
+        connector_type = "connector"
+        hint = (
+            "Use the exact canonical name (e.g., 'source-youtube-analytics', "
+            "'destination-duckdb') or display name (e.g., 'YouTube Analytics', 'DuckDB')."
+        )
 
     raise PyAirbyteInputError(
-        message=f"Could not find source definition for canonical name: {canonical_name}",
+        message=f"Could not find {connector_type} definition for canonical name: {canonical_name}",
         context={
-            "hint": "Use the exact canonical name (e.g., 'source-youtube-analytics') "
-            "or display name (e.g., 'YouTube Analytics'). "
-            "You can list available sources using the connector registry tools.",
+            "hint": hint
+            + " You can list available connectors using the connector registry tools.",
             "searched_for": canonical_name,
         },
     )
@@ -275,11 +364,12 @@ def query_prod_failed_sync_attempts_for_connector(
         ),
     ] = None,
     organization_id: Annotated[
-        str | None,
+        str | OrganizationAliasEnum | None,
         Field(
             description=(
-                "Optional organization ID (UUID) to filter results. "
-                "If provided, only failed attempts from this organization will be returned."
+                "Optional organization ID (UUID) or alias to filter results. "
+                "If provided, only failed attempts from this organization will be returned. "
+                "Accepts '@airbyte-internal' as an alias for the Airbyte internal org."
             ),
             default=None,
         ),
@@ -327,9 +417,12 @@ def query_prod_failed_sync_attempts_for_connector(
     else:
         resolved_definition_id = source_definition_id  # type: ignore[assignment]
 
+    # Resolve organization ID alias
+    resolved_organization_id = OrganizationAliasEnum.resolve(organization_id)
+
     return query_failed_sync_attempts_for_connector(
         connector_definition_id=resolved_definition_id,
-        organization_id=organization_id,
+        organization_id=resolved_organization_id,
         days=days,
         limit=limit,
     )
@@ -346,7 +439,8 @@ def query_prod_connections_by_connector(
         Field(
             description=(
                 "Source connector definition ID (UUID) to search for. "
-                "Exactly one of this or source_canonical_name is required. "
+                "Exactly one of source_definition_id, source_canonical_name, "
+                "destination_definition_id, or destination_canonical_name is required. "
                 "Example: 'afa734e4-3571-11ec-991a-1e0031268139' for YouTube Analytics."
             ),
             default=None,
@@ -357,18 +451,44 @@ def query_prod_connections_by_connector(
         Field(
             description=(
                 "Canonical source connector name to search for. "
-                "Exactly one of this or source_definition_id is required. "
+                "Exactly one of source_definition_id, source_canonical_name, "
+                "destination_definition_id, or destination_canonical_name is required. "
                 "Examples: 'source-youtube-analytics', 'YouTube Analytics'."
             ),
             default=None,
         ),
     ] = None,
-    organization_id: Annotated[
+    destination_definition_id: Annotated[
         str | None,
         Field(
             description=(
-                "Optional organization ID (UUID) to filter results. "
-                "If provided, only connections in this organization will be returned."
+                "Destination connector definition ID (UUID) to search for. "
+                "Exactly one of source_definition_id, source_canonical_name, "
+                "destination_definition_id, or destination_canonical_name is required. "
+                "Example: 'e5c8e66c-a480-4a5e-9c0e-e8e5e4c5c5c5' for DuckDB."
+            ),
+            default=None,
+        ),
+    ] = None,
+    destination_canonical_name: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Canonical destination connector name to search for. "
+                "Exactly one of source_definition_id, source_canonical_name, "
+                "destination_definition_id, or destination_canonical_name is required. "
+                "Examples: 'destination-duckdb', 'DuckDB'."
+            ),
+            default=None,
+        ),
+    ] = None,
+    organization_id: Annotated[
+        str | OrganizationAliasEnum | None,
+        Field(
+            description=(
+                "Optional organization ID (UUID) or alias to filter results. "
+                "If provided, only connections in this organization will be returned. "
+                "Accepts '@airbyte-internal' as an alias for the Airbyte internal org."
             ),
             default=None,
         ),
@@ -378,38 +498,88 @@ def query_prod_connections_by_connector(
         Field(description="Maximum number of results (default: 1000)", default=1000),
     ] = 1000,
 ) -> list[dict[str, Any]]:
-    """Search for all connections using a specific source connector type.
+    """Search for all connections using a specific source or destination connector type.
 
     This tool queries the Airbyte Cloud Prod DB Replica directly for fast results.
-    It finds all connections where the source connector matches the specified type,
-    regardless of how the source is named by users.
+    It finds all connections where the source or destination connector matches the
+    specified type, regardless of how the connector is named by users.
 
     Optionally filter by organization_id to limit results to a specific organization.
+    Use '@airbyte-internal' as an alias for the Airbyte internal organization.
 
     Returns a list of connection dicts with workspace context and clickable Cloud UI URLs.
-    Each dict contains: connection_id, connection_name, connection_url, source_id,
+    For source queries, returns: connection_id, connection_name, connection_url, source_id,
     source_name, source_definition_id, workspace_id, workspace_name, organization_id,
     dataplane_group_id, dataplane_name.
+    For destination queries, returns: connection_id, connection_name, connection_url,
+    destination_id, destination_name, destination_definition_id, workspace_id,
+    workspace_name, organization_id, dataplane_group_id, dataplane_name.
     """
-    # Validate that exactly one of the two parameters is provided
-    if (source_definition_id is None) == (source_canonical_name is None):
+    # Validate that exactly one of the four connector parameters is provided
+    provided_params = [
+        source_definition_id,
+        source_canonical_name,
+        destination_definition_id,
+        destination_canonical_name,
+    ]
+    num_provided = sum(p is not None for p in provided_params)
+    if num_provided != 1:
         raise PyAirbyteInputError(
             message=(
-                "Exactly one of source_definition_id or source_canonical_name "
-                "must be provided, but not both."
+                "Exactly one of source_definition_id, source_canonical_name, "
+                "destination_definition_id, or destination_canonical_name must be provided."
             ),
         )
 
-    # Resolve canonical name to definition ID if needed
+    # Determine if this is a source or destination query and resolve the definition ID
+    is_source_query = (
+        source_definition_id is not None or source_canonical_name is not None
+    )
     resolved_definition_id: str
+
     if source_canonical_name:
         resolved_definition_id = _resolve_canonical_name_to_definition_id(
             canonical_name=source_canonical_name,
         )
+    elif source_definition_id:
+        resolved_definition_id = source_definition_id
+    elif destination_canonical_name:
+        resolved_definition_id = _resolve_canonical_name_to_definition_id(
+            canonical_name=destination_canonical_name,
+        )
     else:
-        resolved_definition_id = source_definition_id  # type: ignore[assignment]
-
-    # Query the database and transform rows to include connection URLs
+        resolved_definition_id = destination_definition_id  # type: ignore[assignment]
+
+    # Resolve organization ID alias
+    resolved_organization_id = OrganizationAliasEnum.resolve(organization_id)
+
+    # Query the database based on connector type
+    if is_source_query:
+        return [
+            {
+                "organization_id": str(row.get("organization_id", "")),
+                "workspace_id": str(row["workspace_id"]),
+                "workspace_name": row.get("workspace_name", ""),
+                "connection_id": str(row["connection_id"]),
+                "connection_name": row.get("connection_name", ""),
+                "connection_url": (
+                    f"{CLOUD_UI_BASE_URL}/workspaces/{row['workspace_id']}"
+                    f"/connections/{row['connection_id']}/status"
+                ),
+                "source_id": str(row["source_id"]),
+                "source_name": row.get("source_name", ""),
+                "source_definition_id": str(row["source_definition_id"]),
+                "dataplane_group_id": str(row.get("dataplane_group_id", "")),
+                "dataplane_name": row.get("dataplane_name", ""),
+            }
+            for row in query_connections_by_connector(
+                connector_definition_id=resolved_definition_id,
+                organization_id=resolved_organization_id,
+                limit=limit,
+            )
+        ]
+
+    # Destination query
     return [
         {
             "organization_id": str(row.get("organization_id", "")),
@@ -421,20 +591,93 @@ def query_prod_connections_by_connector(
                 f"{CLOUD_UI_BASE_URL}/workspaces/{row['workspace_id']}"
                 f"/connections/{row['connection_id']}/status"
             ),
-            "source_id": str(row["source_id"]),
-            "source_name": row.get("source_name", ""),
-            "source_definition_id": str(row["source_definition_id"]),
+            "destination_id": str(row["destination_id"]),
+            "destination_name": row.get("destination_name", ""),
+            "destination_definition_id": str(row["destination_definition_id"]),
             "dataplane_group_id": str(row.get("dataplane_group_id", "")),
             "dataplane_name": row.get("dataplane_name", ""),
         }
-        for row in query_connections_by_connector(
+        for row in query_connections_by_destination_connector(
             connector_definition_id=resolved_definition_id,
-            organization_id=organization_id,
+            organization_id=resolved_organization_id,
             limit=limit,
         )
     ]
 
 
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+)
+def query_prod_workspaces_by_email_domain(
+    email_domain: Annotated[
+        str,
+        Field(
+            description=(
+                "Email domain to search for (e.g., 'motherduck.com', 'fivetran.com'). "
+                "Do not include the '@' symbol. This will find workspaces where users "
+                "have email addresses with this domain."
+            ),
+        ),
+    ],
+    limit: Annotated[
+        int,
+        Field(
+            description="Maximum number of workspaces to return (default: 100)",
+            default=100,
+        ),
+    ] = 100,
+) -> WorkspacesByEmailDomainResult:
+    """Find workspaces by email domain.
+
+    This tool searches for workspaces where users have email addresses matching
+    the specified domain. This is useful for identifying workspaces belonging to
+    specific companies - for example, searching for "motherduck.com" will find
+    workspaces belonging to MotherDuck employees.
+
+    Use cases:
+    - Finding partner organization connections for testing connector fixes
+    - Identifying internal test accounts for specific integrations
+    - Locating workspaces belonging to technology partners
+
+    The returned organization IDs can be used with other tools like
+    `query_prod_connections_by_connector` to find connections within
+    those organizations for safe testing.
+    """
+    # Strip leading @ if provided
+    clean_domain = email_domain.lstrip("@")
+
+    # Query the database
+    rows = query_workspaces_by_email_domain(email_domain=clean_domain, limit=limit)
+
+    # Convert rows to Pydantic models
+    workspaces = [
+        WorkspaceInfo(
+            organization_id=str(row["organization_id"]),
+            workspace_id=str(row["workspace_id"]),
+            workspace_name=row.get("workspace_name", ""),
+            slug=row.get("slug"),
+            email=row.get("email"),
+            dataplane_group_id=str(row["dataplane_group_id"])
+            if row.get("dataplane_group_id")
+            else None,
+            dataplane_name=row.get("dataplane_name"),
+            created_at=row.get("created_at"),
+        )
+        for row in rows
+    ]
+
+    # Extract unique organization IDs
+    unique_org_ids = list(dict.fromkeys(w.organization_id for w in workspaces))
+
+    return WorkspacesByEmailDomainResult(
+        email_domain=clean_domain,
+        total_workspaces_found=len(workspaces),
+        unique_organization_ids=unique_org_ids,
+        workspaces=workspaces,
+    )
+
+
 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

@@ -303,67 +303,56 @@ class RunRegressionTestsResponse(BaseModel):
     open_world=True,
 )
 def run_regression_tests(
-    connection_id: Annotated[str, "The Airbyte Cloud connection ID to test"],
-    skip_read_action: Annotated[
-        bool,
-        "If True, skip the read action (run only spec, check, discover). "
-        "If False (default), run all verbs including read.",
-    ] = False,
-    workspace_id: Annotated[
+    connector_name: Annotated[
+        str,
+        "Connector name to build from source (e.g., 'source-pokeapi'). Required.",
+    ],
+    pr: Annotated[
+        int,
+        "PR number from the airbyte monorepo to checkout and build from (e.g., 70847). Required.",
+    ],
+    connection_id: Annotated[
         str | None,
-        "Optional Airbyte Cloud workspace ID. If provided, validates that the connection "
-        "belongs to this workspace before triggering tests. If omitted, no validation is done.",
+        "Airbyte Cloud connection ID to fetch config/catalog from. "
+        "If not provided, uses GSM integration test secrets.",
     ] = None,
     skip_compare: Annotated[
         bool,
         "If True, skip comparison and run single-version tests only. "
         "If False (default), run comparison tests (target vs control versions).",
     ] = False,
-    connector_image: Annotated[
-        str | None,
-        "Optional connector image with tag for single-version tests "
-        "(e.g., 'airbyte/source-github:1.0.0'). "
-        "If not provided, auto-detected from connection. Only used when skip_compare=True.",
-    ] = None,
-    target_image: Annotated[
+    skip_read_action: Annotated[
+        bool,
+        "If True, skip the read action (run only spec, check, discover). "
+        "If False (default), run all verbs including read.",
+    ] = False,
+    override_test_image: Annotated[
         str | None,
-        "Target connector image (new version) with tag for comparison tests "
-        "(e.g., 'airbyte/source-github:2.0.0'). Optional if connector_name is provided. "
-        "Only used when skip_compare=False (default).",
+        "Override test connector image with tag (e.g., 'airbyte/source-github:1.0.0'). "
+        "Ignored if skip_compare=False.",
     ] = None,
-    control_image: Annotated[
+    override_control_image: Annotated[
         str | None,
-        "Control connector image (baseline version) with tag for comparison tests "
-        "(e.g., 'airbyte/source-github:1.0.0'). Optional if connection_id is provided "
-        "(auto-detected from connection). Only used when skip_compare=False (default).",
+        "Override control connector image (baseline version) with tag. "
+        "Ignored if skip_compare=True.",
     ] = None,
-    connector_name: Annotated[
+    workspace_id: Annotated[
         str | None,
-        "Connector name to build the connector image from source "
-        "(e.g., 'source-pokeapi'). If provided, builds the image locally with tag 'dev'. "
-        "For comparison tests (default), this builds the target image while control is "
-        "auto-detected from the connection. For single-version tests (skip_compare=True), "
-        "this builds the test image.",
-    ] = None,
-    pr: Annotated[
-        int | None,
-        "PR number from the airbyte monorepo to checkout and build from "
-        "(e.g., 70847). Only used when connector_name is provided. "
-        "If not specified, builds from the default branch (master).",
+        "Optional Airbyte Cloud workspace ID. If provided with connection_id, validates "
+        "that the connection belongs to this workspace before triggering tests.",
     ] = None,
 ) -> RunRegressionTestsResponse:
     """Start a regression test run via GitHub Actions workflow.
 
-    This tool triggers either the comparison or single-version regression test
-    workflow depending on the skip_compare parameter:
+    This tool triggers the regression test workflow which builds the connector
+    from the specified PR and runs tests against it.
 
-    - skip_compare=False (default): Triggers comparison regression test workflow.
-      Compares the target connector version against a control (baseline) version.
-      Provide either target_image or connector_name to specify the target version.
+    - 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.
 
-    - skip_compare=True: Triggers single-version regression test workflow.
-      Runs the specified command against the connection and validates the output.
-      No comparison is performed.
+    If connection_id is provided, config/catalog are fetched from Airbyte Cloud.
+    Otherwise, GSM integration test secrets are used.
 
     Returns immediately with a run_id and workflow URL. Check the workflow URL
     to monitor progress and view results.
@@ -385,8 +374,8 @@ def run_regression_tests(
             workflow_url=None,
         )
 
-    # Validate workspace membership if workspace_id is provided
-    if workspace_id:
+    # Validate workspace membership if workspace_id and connection_id are provided
+    if workspace_id and connection_id:
         try:
             validate_connection_workspace(connection_id, workspace_id)
         except (
@@ -401,42 +390,23 @@ def run_regression_tests(
                 workflow_url=None,
             )
 
-    # Build workflow inputs for the unified regression test workflow
+    # Build workflow inputs - connector_name and pr are required
     workflow_inputs: dict[str, str] = {
-        "connection_id": connection_id,
+        "connector_name": connector_name,
+        "pr": str(pr),
     }
 
+    # Add optional inputs
+    if connection_id:
+        workflow_inputs["connection_id"] = connection_id
     if skip_compare:
-        # Single-version mode
         workflow_inputs["skip_compare"] = "true"
-        if connector_image:
-            workflow_inputs["connector_image"] = connector_image
-    else:
-        # Comparison mode (default): validate that we have enough info
-        if not target_image and not connector_name:
-            return RunRegressionTestsResponse(
-                run_id=run_id,
-                status=TestRunStatus.FAILED,
-                message=(
-                    "For comparison regression tests (skip_compare=False, the default), "
-                    "provide either target_image or connector_name so the workflow can "
-                    "determine the target image."
-                ),
-                workflow_url=None,
-            )
-        workflow_inputs["skip_compare"] = "false"
-        if target_image:
-            workflow_inputs["target_image"] = target_image
-        if control_image:
-            workflow_inputs["control_image"] = control_image
-
-    # Common inputs for both modes
     if skip_read_action:
         workflow_inputs["skip_read_action"] = "true"
-    if connector_name:
-        workflow_inputs["connector_name"] = connector_name
-        if pr:
-            workflow_inputs["pr"] = str(pr)
+    if override_test_image:
+        workflow_inputs["override_test_image"] = override_test_image
+    if override_control_image:
+        workflow_inputs["override_control_image"] = override_control_image
 
     mode_description = "single-version" if skip_compare else "comparison"
     try:
@@ -460,12 +430,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 ""
     return RunRegressionTestsResponse(
         run_id=run_id,
         status=TestRunStatus.QUEUED,
         message=(
-            f"{mode_description.capitalize()} regression test workflow triggered for "
-            f"connection {connection_id}. View progress at: {view_url}"
+            f"{mode_description.capitalize()} regression test workflow triggered "
+            f"for {connector_name} (PR #{pr}){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

@@ -22,6 +22,8 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_ACTORS_PINNED_TO_VERSION,
     SELECT_CONNECTIONS_BY_CONNECTOR,
     SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
+    SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR,
+    SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
     SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
@@ -30,6 +32,7 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
     SELECT_SYNC_RESULTS_FOR_VERSION,
     SELECT_WORKSPACE_INFO,
+    SELECT_WORKSPACES_BY_EMAIL_DOMAIN,
 )
 
 logger = logging.getLogger(__name__)
@@ -113,6 +116,48 @@ def query_connections_by_connector(
     )
 
 
+def query_connections_by_destination_connector(
+    connector_definition_id: str,
+    organization_id: str | None = None,
+    limit: int = 1000,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query connections by destination connector type, optionally filtered by organization.
+
+    Args:
+        connector_definition_id: Destination connector definition UUID to filter by
+        organization_id: Optional organization UUID to search within
+        limit: Maximum number of results (default: 1000)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of connection records with workspace and dataplane info
+    """
+    # Use separate queries to avoid pg8000 NULL parameter type issues
+    if organization_id is None:
+        return _run_sql_query(
+            SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR,
+            parameters={
+                "connector_definition_id": connector_definition_id,
+                "limit": limit,
+            },
+            query_name="SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR",
+            gsm_client=gsm_client,
+        )
+
+    return _run_sql_query(
+        SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "organization_id": organization_id,
+            "limit": limit,
+        },
+        query_name="SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG",
+        gsm_client=gsm_client,
+    )
+
+
 def query_connector_versions(
     connector_definition_id: str,
     *,
@@ -337,3 +382,37 @@ def query_org_workspaces(
         query_name="SELECT_ORG_WORKSPACES",
         gsm_client=gsm_client,
     )
+
+
+def query_workspaces_by_email_domain(
+    email_domain: str,
+    limit: int = 100,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query workspaces by email domain.
+
+    This is useful for identifying workspaces based on user email domains.
+    For example, searching for "motherduck.com" will find workspaces where users have
+    @motherduck.com email addresses, which may belong to partner accounts.
+
+    Args:
+        email_domain: Email domain to search for (e.g., "motherduck.com", "fivetran.com").
+            Do not include the "@" symbol.
+        limit: Maximum number of results (default: 100)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of workspace records with organization_id, workspace_id, workspace_name,
+        slug, email, dataplane_group_id, dataplane_name, and created_at.
+        Results are ordered by organization_id and workspace_name.
+    """
+    # Strip leading @ if provided
+    clean_domain = email_domain.lstrip("@")
+
+    return _run_sql_query(
+        SELECT_WORKSPACES_BY_EMAIL_DOMAIN,
+        parameters={"email_domain": clean_domain, "limit": limit},
+        query_name="SELECT_WORKSPACES_BY_EMAIL_DOMAIN",
+        gsm_client=gsm_client,
+    )

airbyte_ops_mcp/prod_db_access/sql.py

@@ -131,6 +131,61 @@ SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG = sqlalchemy.text(
     """
 )
 
+# Query connections by DESTINATION connector type (no organization filter)
+SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         connection.id AS connection_id,
+         connection.name AS connection_name,
+         connection.destination_id,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         destination_actor.actor_definition_id AS destination_definition_id,
+         destination_actor.name AS destination_name
+    FROM connection
+    JOIN actor AS destination_actor
+      ON connection.destination_id = destination_actor.id
+    JOIN workspace
+      ON destination_actor.workspace_id = workspace.id
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         destination_actor.actor_definition_id = :connector_definition_id
+    LIMIT :limit
+    """
+)
+
+# Query connections by DESTINATION connector type, filtered by organization
+SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG = sqlalchemy.text(
+    """
+    SELECT
+         connection.id AS connection_id,
+         connection.name AS connection_name,
+         connection.destination_id,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         destination_actor.actor_definition_id AS destination_definition_id,
+         destination_actor.name AS destination_name
+    FROM connection
+    JOIN actor AS destination_actor
+      ON connection.destination_id = destination_actor.id
+    JOIN workspace
+      ON destination_actor.workspace_id = workspace.id
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         destination_actor.actor_definition_id = :connector_definition_id
+     AND workspace.organization_id = :organization_id
+    LIMIT :limit
+    """
+)
+
 # =============================================================================
 # Connector Version Queries
 # =============================================================================
@@ -441,3 +496,34 @@ SELECT_ORG_WORKSPACES = sqlalchemy.text(
          workspace.name
     """
 )
+
+# =============================================================================
+# Workspace Lookup by Email Domain
+# =============================================================================
+
+# Find workspaces by email domain
+# This is useful for identifying workspaces based on user email domains
+# (e.g., finding partner accounts like MotherDuck by searching for "motherduck.com")
+SELECT_WORKSPACES_BY_EMAIL_DOMAIN = sqlalchemy.text(
+    """
+    SELECT DISTINCT
+         workspace.organization_id,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.slug,
+         workspace.email,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         workspace.created_at
+    FROM workspace
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         workspace.email LIKE '%@' || :email_domain
+     AND workspace.tombstone = false
+    ORDER BY
+         workspace.organization_id,
+         workspace.name
+    LIMIT :limit
+    """
+)