airbyte-internal-ops 0.1.10__tar.gz → 0.1.11__tar.gz

{airbyte_internal_ops-0.1.10 → airbyte_internal_ops-0.1.11}/.github/workflows/connector-live-test.yml

@@ -13,6 +13,11 @@ on:
         description: "Connector name to build from source (e.g., 'source-pokeapi'). If provided, builds the image locally."
         required: false
         type: string
+      airbyte_ref:
+        description: "Git ref or PR number to checkout from airbyte repo (e.g., 'master', '70847', 'refs/pull/70847/head'). Only used when connector_name is provided."
+        required: false
+        type: string
+        default: "master"
       command:
         description: "Airbyte command to run"
         required: false
@@ -53,6 +58,29 @@ jobs:
       - name: Install dependencies
         run: uv sync --group dev
 
+      - name: Resolve Airbyte ref
+        if: ${{ inputs.connector_name != '' }}
+        id: resolve-airbyte-ref
+        run: |
+          REF="${{ inputs.airbyte_ref }}"
+          # If the input is all digits, treat it as a PR number
+          if [[ "$REF" =~ ^[0-9]+$ ]]; then
+            echo "resolved_ref=refs/pull/${REF}/head" >> "$GITHUB_OUTPUT"
+            echo "Resolved PR number $REF to refs/pull/${REF}/head"
+          else
+            echo "resolved_ref=$REF" >> "$GITHUB_OUTPUT"
+            echo "Using ref as-is: $REF"
+          fi
+
+      - name: Checkout Airbyte repo
+        if: ${{ inputs.connector_name != '' }}
+        uses: actions/checkout@v6
+        with:
+          repository: airbytehq/airbyte
+          ref: ${{ steps.resolve-airbyte-ref.outputs.resolved_ref }}
+          path: airbyte
+          fetch-depth: 1
+
       - name: Run Live Test
         id: live-test
         env:
@@ -67,6 +95,7 @@ jobs:
 
           if [ -n "${{ inputs.connector_name }}" ]; then
             ARGS+=(--connector-name "${{ inputs.connector_name }}")
+            ARGS+=(--repo-root "${{ github.workspace }}/airbyte")
           fi
 
           if [ -n "${{ inputs.connection_id }}" ]; then

{airbyte_internal_ops-0.1.10 → airbyte_internal_ops-0.1.11}/.github/workflows/connector-regression-test.yml

@@ -18,6 +18,11 @@ on:
         description: "Connector name to build target image from source (e.g., 'source-pokeapi'). If provided, builds the target image locally."
         required: false
         type: string
+      airbyte_ref:
+        description: "Git ref or PR number to checkout from airbyte repo (e.g., 'master', '70847', 'refs/pull/70847/head'). Only used when connector_name is provided."
+        required: false
+        type: string
+        default: "master"
       command:
         description: "Airbyte command to run"
         required: false
@@ -51,6 +56,11 @@ on:
         description: "Connector name to build target image from source (e.g., 'source-pokeapi')."
         required: false
         type: string
+      airbyte_ref:
+        description: "Git ref or PR number to checkout from airbyte repo. Only used when connector_name is provided."
+        required: false
+        type: string
+        default: "master"
       command:
         description: "Airbyte command to run (spec, check, discover, read)"
         required: false
@@ -79,6 +89,8 @@ on:
         required: false
       AIRBYTE_CLOUD_CLIENT_SECRET:
         required: false
+      GCP_GSM_CREDENTIALS:
+        required: false
 
 jobs:
   regression-test:
@@ -105,11 +117,35 @@ jobs:
       - name: Install dependencies
         run: uv sync --group dev
 
+      - name: Resolve Airbyte ref
+        if: ${{ inputs.connector_name != '' }}
+        id: resolve-airbyte-ref
+        run: |
+          REF="${{ inputs.airbyte_ref }}"
+          # If the input is all digits, treat it as a PR number
+          if [[ "$REF" =~ ^[0-9]+$ ]]; then
+            echo "resolved_ref=refs/pull/${REF}/head" >> "$GITHUB_OUTPUT"
+            echo "Resolved PR number $REF to refs/pull/${REF}/head"
+          else
+            echo "resolved_ref=$REF" >> "$GITHUB_OUTPUT"
+            echo "Using ref as-is: $REF"
+          fi
+
+      - name: Checkout Airbyte repo
+        if: ${{ inputs.connector_name != '' }}
+        uses: actions/checkout@v6
+        with:
+          repository: airbytehq/airbyte
+          ref: ${{ steps.resolve-airbyte-ref.outputs.resolved_ref }}
+          path: airbyte
+          fetch-depth: 1
+
       - name: Run Regression Test
         id: regression-test
         env:
           AIRBYTE_CLOUD_CLIENT_ID: ${{ secrets.AIRBYTE_CLOUD_CLIENT_ID }}
           AIRBYTE_CLOUD_CLIENT_SECRET: ${{ secrets.AIRBYTE_CLOUD_CLIENT_SECRET }}
+          GCP_GSM_CREDENTIALS: ${{ secrets.GCP_GSM_CREDENTIALS }}
         run: |
           ARGS=(--command "${{ inputs.command }}")
 
@@ -123,6 +159,7 @@ jobs:
 
           if [ -n "${{ inputs.connector_name }}" ]; then
             ARGS+=(--connector-name "${{ inputs.connector_name }}")
+            ARGS+=(--repo-root "${{ github.workspace }}/airbyte")
           fi
 
           if [ -n "${{ inputs.connection_id }}" ]; then

airbyte_internal_ops-0.1.11/.github/workflows/live-tests-ci.yml

@@ -0,0 +1,33 @@
+# CI smoke test for live_tests code changes
+# Runs a lightweight regression test to validate live_tests code works correctly
+name: Live Tests CI
+
+permissions:
+  contents: read
+  checks: write
+
+on:
+  pull_request:
+    paths:
+      - 'src/airbyte_ops_mcp/live_tests/**'
+      - '.github/workflows/live-tests-ci.yml'
+      - '.github/workflows/connector-regression-test.yml'
+
+  # Allow manual triggering for testing
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  smoke-test:
+    name: Live Tests Smoke Test
+    uses: ./.github/workflows/connector-regression-test.yml
+    with:
+      # Use source-pokeapi as a stable, public connector for smoke testing
+      target_image: "airbyte/source-pokeapi:0.3.0"
+      control_image: "airbyte/source-pokeapi:0.2.0"
+      # spec is the fastest command and doesn't require credentials
+      command: "spec"
+    # No secrets needed for spec command with public connector

{airbyte_internal_ops-0.1.10 → airbyte_internal_ops-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.1.10
+Version: 0.1.11
 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.1.10 → airbyte_internal_ops-0.1.11}/src/airbyte_ops_mcp/cli/cloud.py

@@ -18,10 +18,13 @@ import shutil
 import signal
 import socket
 import subprocess
+import tempfile
 import time
 from pathlib import Path
 from typing import Annotated, Literal
 
+import requests
+import yaml
 from airbyte_cdk.models.connector_metadata import MetadataFile
 from airbyte_cdk.utils.connector_paths import find_connector_root_from_name
 from airbyte_cdk.utils.docker import build_connector_image, verify_docker_installation
@@ -42,6 +45,7 @@ from airbyte_ops_mcp.constants import (
     DEFAULT_CLOUD_SQL_PROXY_PORT,
     ENV_GCP_PROD_DB_ACCESS_CREDENTIALS,
 )
+from airbyte_ops_mcp.live_tests.cdk_secrets import get_first_config_from_secrets
 from airbyte_ops_mcp.live_tests.ci_output import (
     generate_regression_report,
     get_report_summary,
@@ -507,6 +511,49 @@ def _build_connector_image_from_source(
     return built_image
 
 
+def _fetch_control_image_from_metadata(connector_name: str) -> str | None:
+    """Fetch the current released connector image from metadata.yaml on main branch.
+
+    This fetches the connector's metadata.yaml from the airbyte monorepo's master branch
+    and extracts the dockerRepository and dockerImageTag to construct the control image.
+
+    Args:
+        connector_name: The connector name (e.g., 'source-github').
+
+    Returns:
+        The full connector image with tag (e.g., 'airbyte/source-github:1.0.0'),
+        or None if the metadata could not be fetched or parsed.
+    """
+    metadata_url = (
+        f"https://raw.githubusercontent.com/airbytehq/airbyte/master/"
+        f"airbyte-integrations/connectors/{connector_name}/metadata.yaml"
+    )
+    response = requests.get(metadata_url, timeout=30)
+    if not response.ok:
+        print_error(
+            f"Failed to fetch metadata for {connector_name}: "
+            f"HTTP {response.status_code} from {metadata_url}"
+        )
+        return None
+
+    metadata = yaml.safe_load(response.text)
+    if not isinstance(metadata, dict):
+        print_error(f"Invalid metadata format for {connector_name}: expected dict")
+        return None
+
+    data = metadata.get("data", {})
+    docker_repository = data.get("dockerRepository")
+    docker_image_tag = data.get("dockerImageTag")
+
+    if not docker_repository or not docker_image_tag:
+        print_error(
+            f"Could not find dockerRepository/dockerImageTag in metadata for {connector_name}"
+        )
+        return None
+
+    return f"{docker_repository}:{docker_image_tag}"
+
+
 @connector_app.command(name="live-test")
 def live_test(
     connector_image: Annotated[
@@ -906,10 +953,48 @@ def regression_test(
         if not resolved_control_image and connection_data.connector_image:
             resolved_control_image = connection_data.connector_image
             print_success(f"Auto-detected control image: {resolved_control_image}")
+    elif config_path:
+        config_file = Path(config_path)
+        catalog_file = Path(catalog_path) if catalog_path else None
+    elif connector_name:
+        # Fallback: fetch integration test secrets from GSM using PyAirbyte API
+        print_success(
+            f"No connection_id or config_path provided. "
+            f"Attempting to fetch integration test config from GSM for {connector_name}..."
+        )
+        gsm_config = get_first_config_from_secrets(connector_name)
+        if gsm_config:
+            # Write config to a temp file (not in output_path to avoid artifact upload)
+            gsm_config_dir = Path(
+                tempfile.mkdtemp(prefix=f"gsm-config-{connector_name}-")
+            )
+            gsm_config_dir.chmod(0o700)
+            gsm_config_file = gsm_config_dir / "config.json"
+            gsm_config_file.write_text(json.dumps(gsm_config, indent=2))
+            gsm_config_file.chmod(0o600)
+            config_file = gsm_config_file
+            catalog_file = None
+            print_success(
+                f"Fetched integration test config from GSM for {connector_name}"
+            )
+        else:
+            print_error(
+                f"Failed to fetch integration test config from GSM for {connector_name}."
+            )
+            config_file = None
+            catalog_file = None
     else:
-        config_file = Path(config_path) if config_path else None
+        config_file = None
         catalog_file = Path(catalog_path) if catalog_path else None
 
+    # Auto-detect control_image from metadata.yaml if connector_name is provided
+    if not resolved_control_image and connector_name:
+        resolved_control_image = _fetch_control_image_from_metadata(connector_name)
+        if resolved_control_image:
+            print_success(
+                f"Auto-detected control image from metadata.yaml: {resolved_control_image}"
+            )
+
     # Validate that we have both images
     if not resolved_target_image:
         write_github_output("success", False)
@@ -923,8 +1008,9 @@ def regression_test(
         write_github_output("success", False)
         write_github_output("error", "No control image specified")
         exit_with_error(
-            "You must provide one of the following: a control_image or a connection_id "
-            "for a connection that has an associated connector image."
+            "You must provide one of the following: a control_image, a connection_id "
+            "for a connection that has an associated connector image, or a connector_name "
+            "to auto-detect the control image from the airbyte repo's metadata.yaml."
         )
 
     # Pull images if they weren't just built locally

airbyte_internal_ops-0.1.11/src/airbyte_ops_mcp/github_actions.py

@@ -0,0 +1,197 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""GitHub Actions API utilities.
+
+This module provides core utilities for interacting with GitHub Actions workflows,
+including workflow dispatch, run discovery, and authentication. These utilities
+are used by MCP tools but are not MCP-specific.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+import requests
+
+GITHUB_API_BASE = "https://api.github.com"
+
+
+def resolve_github_token(preferred_env_vars: list[str] | None = None) -> str:
+    """Resolve GitHub token from environment variables.
+
+    Checks environment variables in order of preference, returning the first
+    non-empty value found.
+
+    Args:
+        preferred_env_vars: List of environment variable names to check in order.
+            Defaults to ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"].
+
+    Returns:
+        GitHub token string.
+
+    Raises:
+        ValueError: If no GitHub token is found in any of the specified env vars.
+    """
+    if preferred_env_vars is None:
+        preferred_env_vars = ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"]
+
+    for env_var in preferred_env_vars:
+        token = os.getenv(env_var)
+        if token:
+            return token
+
+    env_var_list = ", ".join(preferred_env_vars)
+    raise ValueError(
+        f"No GitHub token found. Set one of: {env_var_list} environment variable."
+    )
+
+
+@dataclass
+class WorkflowDispatchResult:
+    """Result of triggering a workflow dispatch."""
+
+    workflow_url: str
+    """URL to the workflow file (e.g., .../actions/workflows/my-workflow.yml)"""
+
+    run_id: int | None = None
+    """GitHub Actions run ID, if discovered"""
+
+    run_url: str | None = None
+    """Direct URL to the workflow run, if discovered"""
+
+
+def find_workflow_run(
+    owner: str,
+    repo: str,
+    workflow_file: str,
+    ref: str,
+    token: str,
+    created_after: datetime,
+    max_wait_seconds: float = 5.0,
+) -> tuple[int, str] | None:
+    """Find a workflow run that was created after a given time.
+
+    This is used to find the run that was just triggered via workflow_dispatch.
+    Polls for up to max_wait_seconds to handle GitHub API eventual consistency.
+
+    Args:
+        owner: Repository owner
+        repo: Repository name
+        workflow_file: Workflow file name
+        ref: Git ref the workflow was triggered on
+        token: GitHub API token
+        created_after: Only consider runs created after this time
+        max_wait_seconds: Maximum time to wait for run to appear (default 5 seconds)
+
+    Returns:
+        Tuple of (run_id, run_url) if found, None otherwise.
+    """
+    url = (
+        f"{GITHUB_API_BASE}/repos/{owner}/{repo}/actions/workflows/{workflow_file}/runs"
+    )
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    params = {
+        "branch": ref,
+        "event": "workflow_dispatch",
+        "per_page": 5,
+    }
+
+    # Add a small buffer to handle timestamp precision differences between
+    # local time and GitHub's created_at (which has second resolution)
+    search_after = created_after - timedelta(seconds=2)
+
+    deadline = time.monotonic() + max_wait_seconds
+    attempt = 0
+
+    while time.monotonic() < deadline:
+        if attempt > 0:
+            time.sleep(1.0)
+        attempt += 1
+
+        response = requests.get(url, headers=headers, params=params, timeout=30)
+        if not response.ok:
+            continue
+
+        data = response.json()
+        runs = data.get("workflow_runs", [])
+
+        for run in runs:
+            run_created_at = datetime.fromisoformat(
+                run["created_at"].replace("Z", "+00:00")
+            )
+            if run_created_at >= search_after:
+                return run["id"], run["html_url"]
+
+    return None
+
+
+def trigger_workflow_dispatch(
+    owner: str,
+    repo: str,
+    workflow_file: str,
+    ref: str,
+    inputs: dict,
+    token: str,
+    find_run: bool = True,
+    max_wait_seconds: float = 5.0,
+) -> WorkflowDispatchResult:
+    """Trigger a GitHub Actions workflow via workflow_dispatch.
+
+    Args:
+        owner: Repository owner (e.g., "airbytehq")
+        repo: Repository name (e.g., "airbyte-ops-mcp")
+        workflow_file: Workflow file name (e.g., "connector-live-test.yml")
+        ref: Git ref to run the workflow on (branch name)
+        inputs: Workflow inputs dictionary
+        token: GitHub API token
+        find_run: Whether to attempt to find the run after dispatch (default True)
+        max_wait_seconds: Maximum time to wait for run discovery (default 5 seconds)
+
+    Returns:
+        WorkflowDispatchResult with workflow URL and optionally run ID/URL.
+
+    Raises:
+        requests.HTTPError: If API request fails.
+    """
+    dispatch_time = datetime.now(tz=datetime.now().astimezone().tzinfo)
+
+    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/actions/workflows/{workflow_file}/dispatches"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    payload = {
+        "ref": ref,
+        "inputs": inputs,
+    }
+
+    response = requests.post(url, headers=headers, json=payload, timeout=30)
+    response.raise_for_status()
+
+    workflow_url = (
+        f"https://github.com/{owner}/{repo}/actions/workflows/{workflow_file}"
+    )
+
+    if not find_run:
+        return WorkflowDispatchResult(workflow_url=workflow_url)
+
+    # Best-effort lookup of the run that was just triggered
+    run_info = find_workflow_run(
+        owner, repo, workflow_file, ref, token, dispatch_time, max_wait_seconds
+    )
+    if run_info:
+        run_id, run_url = run_info
+        return WorkflowDispatchResult(
+            workflow_url=workflow_url,
+            run_id=run_id,
+            run_url=run_url,
+        )
+
+    return WorkflowDispatchResult(workflow_url=workflow_url)

airbyte_internal_ops-0.1.11/src/airbyte_ops_mcp/live_tests/cdk_secrets.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""Fetch connector test secrets using the PyAirbyte secrets API.
+
+This module uses the PyAirbyte GoogleGSMSecretManager to retrieve
+integration test secrets from Google Secret Manager for connectors.
+
+Usage:
+    from airbyte_ops_mcp.live_tests.cdk_secrets import get_first_config_from_secrets
+
+    # Fetch the first config for a connector
+    config = get_first_config_from_secrets("source-github")
+    if config:
+        # Use the config dict
+        ...
+
+Note: Requires GCP credentials with access to the integration testing project.
+The credentials can be provided via:
+- GOOGLE_APPLICATION_CREDENTIALS environment variable
+- GCP_GSM_CREDENTIALS environment variable (JSON string)
+- Application Default Credentials
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from airbyte.secrets import GoogleGSMSecretManager
+
+logger = logging.getLogger(__name__)
+
+# Default GCP project for integration test secrets
+DEFAULT_GSM_PROJECT = "dataline-integration-testing"
+
+
+def get_first_config_from_secrets(
+    connector_name: str,
+    project: str = DEFAULT_GSM_PROJECT,
+) -> dict | None:
+    """Fetch the first integration test config for a connector from GSM.
+
+    This function uses the PyAirbyte GoogleGSMSecretManager to fetch secrets
+    labeled with the connector name and returns the first one as a parsed dict.
+
+    Args:
+        connector_name: The connector name (e.g., 'source-github').
+        project: The GCP project ID containing the secrets.
+
+    Returns:
+        The parsed config dict, or None if no secrets are found or fetching fails.
+    """
+    # Get credentials from environment
+    credentials_json: str | None = None
+    credentials_path: str | None = None
+
+    if "GCP_GSM_CREDENTIALS" in os.environ:
+        credentials_json = os.environ["GCP_GSM_CREDENTIALS"]
+    elif "GOOGLE_APPLICATION_CREDENTIALS" in os.environ:
+        credentials_path = os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
+
+    # If no explicit credentials, GoogleGSMSecretManager will try ADC
+    try:
+        gsm = GoogleGSMSecretManager(
+            project=project,
+            credentials_json=credentials_json,
+            credentials_path=credentials_path,
+        )
+    except Exception as e:
+        logger.warning(f"Failed to initialize GSM client: {e}")
+        return None
+
+    logger.info(f"Fetching integration test config for {connector_name} from GSM")
+
+    try:
+        # fetch_connector_secret returns the first secret matching the connector label
+        secret_handle = gsm.fetch_connector_secret(connector_name)
+        # parse_json() calls get_value() internally and parses the result
+        config = secret_handle.parse_json()
+        logger.info(f"Successfully fetched config for {connector_name}")
+        return dict(config) if config else None
+
+    except StopIteration:
+        logger.warning(f"No secrets found for connector {connector_name}")
+        return None
+    except Exception as e:
+        # Log the exception type but not the message (may contain sensitive info)
+        logger.warning(
+            f"Failed to fetch config for {connector_name}: {type(e).__name__}"
+        )
+        return None

{airbyte_internal_ops-0.1.10 → airbyte_internal_ops-0.1.11}/src/airbyte_ops_mcp/live_tests/ci_output.py

@@ -142,6 +142,35 @@ def _format_delta(delta: int) -> str:
     return "0"
 
 
+def _get_github_run_url() -> str | None:
+    """Get the URL to the current GitHub Actions workflow run.
+
+    Returns:
+        The workflow run URL, or None if not running in GitHub Actions.
+    """
+    server_url = os.getenv("GITHUB_SERVER_URL")
+    repository = os.getenv("GITHUB_REPOSITORY")
+    run_id = os.getenv("GITHUB_RUN_ID")
+
+    if not all([server_url, repository, run_id]):
+        return None
+
+    return f"{server_url}/{repository}/actions/runs/{run_id}"
+
+
+def _get_github_artifacts_url() -> str | None:
+    """Get the URL to the artifacts section of the current workflow run.
+
+    Returns:
+        The artifacts section URL, or None if not running in GitHub Actions.
+    """
+    run_url = _get_github_run_url()
+    if not run_url:
+        return None
+
+    return f"{run_url}#artifacts"
+
+
 def generate_regression_report(
     target_image: str,
     control_image: str,
@@ -190,6 +219,9 @@ def generate_regression_report(
         target_image.rsplit(":", 1)[0] if ":" in target_image else target_image
     )
 
+    run_url = _get_github_run_url()
+    artifacts_url = _get_github_artifacts_url()
+
     lines: list[str] = [
         "# Regression Test Report",
         "",
@@ -200,12 +232,23 @@ def generate_regression_report(
         f"- **Control Version:** `{control_version}`",
         f"- **Target Version:** `{target_version}`",
         f"- **Command:** `{command.upper()}`",
-        f"- **Artifacts:** `{artifact_name}`",
-        "",
-        "## Summary",
-        "",
     ]
 
+    if run_url:
+        lines.append(f"- **Workflow Run:** [View Execution]({run_url})")
+    if artifacts_url:
+        lines.append(f"- **Artifacts:** [Download `{artifact_name}`]({artifacts_url})")
+    else:
+        lines.append(f"- **Artifacts:** `{artifact_name}`")
+
+    lines.extend(
+        [
+            "",
+            "## Summary",
+            "",
+        ]
+    )
+
     if regression_detected:
         if target_result["success"] and not control_result["success"]:
             lines.append("**Result:** Target succeeded, control failed (improvement)")
@@ -341,9 +384,16 @@ def get_report_summary(report_path: Path) -> str:
         f"regression-test-artifacts-{run_id}" if run_id else "regression-test-artifacts"
     )
 
+    artifacts_url = _get_github_artifacts_url()
+    artifact_link = (
+        f"[`{artifact_name}`]({artifacts_url})"
+        if artifacts_url
+        else f"`{artifact_name}`"
+    )
+
     return f"""## Regression Test Report
 
-Full report available in the **Regression Test Report** check or in artifact `{artifact_name}`.
+Full report available in the **Regression Test Report** check or in artifact {artifact_link}.
 
 See the Checks tab for the complete report with message counts and execution details.
 """

{airbyte_internal_ops-0.1.10 → airbyte_internal_ops-0.1.11}/src/airbyte_ops_mcp/live_tests/connector_runner.py

@@ -168,6 +168,9 @@ 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)
             self._prepare_data_directory(temp_path)
 
             docker_cmd = self._build_docker_command(temp_path)