airbyte-internal-ops 0.2.2__tar.gz → 0.2.3__tar.gz

{airbyte_internal_ops-0.2.2 → airbyte_internal_ops-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.2.2
+Version: 0.2.3
 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.2.2 → airbyte_internal_ops-0.2.3}/src/airbyte_ops_mcp/cli/registry.py

@@ -5,6 +5,7 @@ This module provides CLI wrappers for registry operations. The core logic
 lives in the `airbyte_ops_mcp.registry` capability module.
 
 Commands:
+    airbyte-ops registry connector compute-prerelease-tag - Compute prerelease version tag
     airbyte-ops registry connector publish-prerelease - Publish connector prerelease
     airbyte-ops registry connector publish - Publish connector (apply/rollback version override)
     airbyte-ops registry image inspect - Inspect Docker image on DockerHub
@@ -12,9 +13,12 @@ Commands:
 
 from __future__ import annotations
 
+import contextlib
+import sys
 from pathlib import Path
 from typing import Annotated
 
+import yaml
 from cyclopts import App, Parameter
 
 from airbyte_ops_mcp.cli._base import app
@@ -24,8 +28,15 @@ from airbyte_ops_mcp.cli._shared import (
     print_json,
     print_success,
 )
+from airbyte_ops_mcp.github_actions import (
+    get_file_contents_at_ref,
+    resolve_github_token,
+)
 from airbyte_ops_mcp.mcp.github import get_docker_image_info
-from airbyte_ops_mcp.mcp.prerelease import publish_connector_to_airbyte_registry
+from airbyte_ops_mcp.mcp.prerelease import (
+    compute_prerelease_docker_image_tag,
+    publish_connector_to_airbyte_registry,
+)
 from airbyte_ops_mcp.registry import (
     ConnectorPublishResult,
     PublishAction,
@@ -47,6 +58,111 @@ image_app = App(name="image", help="Docker image operations.")
 registry_app.command(image_app)
 
 
+AIRBYTE_REPO_OWNER = "airbytehq"
+AIRBYTE_REPO_NAME = "airbyte"
+CONNECTOR_PATH_PREFIX = "airbyte-integrations/connectors"
+
+
+def _get_connector_version_from_github(
+    connector_name: str,
+    ref: str,
+    token: str | None = None,
+) -> str | None:
+    """Fetch connector version from metadata.yaml via GitHub API.
+
+    Args:
+        connector_name: Connector name (e.g., "source-github")
+        ref: Git ref (commit SHA, branch name, or tag)
+        token: GitHub API token (optional for public repos)
+
+    Returns:
+        Version string from metadata.yaml, or None if not found.
+    """
+    path = f"{CONNECTOR_PATH_PREFIX}/{connector_name}/metadata.yaml"
+    contents = get_file_contents_at_ref(
+        owner=AIRBYTE_REPO_OWNER,
+        repo=AIRBYTE_REPO_NAME,
+        path=path,
+        ref=ref,
+        token=token,
+    )
+    if contents is None:
+        return None
+
+    metadata = yaml.safe_load(contents)
+    return metadata.get("data", {}).get("dockerImageTag")
+
+
+@connector_app.command(name="compute-prerelease-tag")
+def compute_prerelease_tag(
+    connector_name: Annotated[
+        str,
+        Parameter(help="Connector name (e.g., 'source-github')."),
+    ],
+    sha: Annotated[
+        str,
+        Parameter(help="Git commit SHA (full or at least 7 characters)."),
+    ],
+    base_version: Annotated[
+        str | None,
+        Parameter(
+            help="Base version override. If not provided, fetched from metadata.yaml at the given SHA."
+        ),
+    ] = None,
+) -> None:
+    """Compute the pre-release docker image tag.
+
+    Outputs the version tag to stdout for easy capture in shell scripts.
+    This is the single source of truth for pre-release version format.
+
+    The command fetches the connector's metadata.yaml from GitHub at the given SHA
+    to determine the base version. It also compares against the master branch and
+    prints a warning to stderr if no version bump is detected.
+
+    If --base-version is provided, it is used directly instead of fetching from GitHub.
+
+    Example:
+        airbyte-ops registry connector compute-prerelease-tag --connector-name source-github --sha abcdef1234567
+        # Output: 1.2.3-preview.abcdef1
+
+        airbyte-ops registry connector compute-prerelease-tag --connector-name source-github --sha abcdef1234567 --base-version 1.2.3
+        # Output: 1.2.3-preview.abcdef1 (uses provided version, skips GitHub API)
+    """
+    # Try to get a GitHub token (optional, but helps avoid rate limiting)
+    # Token resolution may fail if no token is configured, which is fine for public repos
+    token: str | None = None
+    with contextlib.suppress(ValueError):
+        token = resolve_github_token()
+
+    # Determine base version
+    version: str
+    if base_version:
+        version = base_version
+    else:
+        # Fetch version from metadata.yaml at the given SHA
+        fetched_version = _get_connector_version_from_github(connector_name, sha, token)
+        if fetched_version is None:
+            print(
+                f"Error: Could not fetch metadata.yaml for {connector_name} at ref {sha}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        version = fetched_version
+
+    # Compare with master branch version and warn if no bump detected
+    master_version = _get_connector_version_from_github(connector_name, "master", token)
+    if master_version and master_version == version:
+        print(
+            f"Warning: No version bump detected for {connector_name}. "
+            f"Version {version} matches master branch.",
+            file=sys.stderr,
+        )
+
+    # Compute and output the prerelease tag
+    tag = compute_prerelease_docker_image_tag(version, sha)
+    print(tag)
+
+
 @connector_app.command(name="publish-prerelease")
 def publish_prerelease(
     connector_name: Annotated[

{airbyte_internal_ops-0.2.2 → airbyte_internal_ops-0.2.3}/src/airbyte_ops_mcp/github_actions.py

@@ -106,6 +106,51 @@ class WorkflowJobInfo:
     """ISO 8601 timestamp when the job completed"""
 
 
+def get_file_contents_at_ref(
+    owner: str,
+    repo: str,
+    path: str,
+    ref: str,
+    token: str | None = None,
+) -> str | None:
+    """Fetch file contents from GitHub at a specific ref.
+
+    Uses the GitHub Contents API to retrieve file contents at a specific
+    commit SHA, branch, or tag. This allows reading files without having
+    the repository checked out locally.
+
+    Args:
+        owner: Repository owner (e.g., "airbytehq")
+        repo: Repository name (e.g., "airbyte")
+        path: Path to the file within the repository
+        ref: Git ref (commit SHA, branch name, or tag)
+        token: GitHub API token (optional for public repos, but recommended
+            to avoid rate limiting)
+
+    Returns:
+        File contents as a string, or None if the file doesn't exist.
+
+    Raises:
+        requests.HTTPError: If API request fails (except 404).
+    """
+    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/contents/{path}"
+    headers = {
+        "Accept": "application/vnd.github.raw+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    params = {"ref": ref}
+
+    response = requests.get(url, headers=headers, params=params, timeout=30)
+    if response.status_code == 404:
+        return None
+    response.raise_for_status()
+
+    return response.text
+
+
 def get_workflow_jobs(
     owner: str,
     repo: str,

{airbyte_internal_ops-0.2.2 → airbyte_internal_ops-0.2.3}/src/airbyte_ops_mcp/mcp/prerelease.py

@@ -31,6 +31,45 @@ PRERELEASE_TOKEN_ENV_VARS = [
     "GITHUB_TOKEN",
 ]
 
+# =============================================================================
+# Pre-release Version Tag Constants
+# =============================================================================
+
+PRERELEASE_TAG_PREFIX = "preview"
+"""The prefix used for pre-release version tags (e.g., '1.2.3-preview.abcde12')."""
+
+PRERELEASE_SHA_LENGTH = 7
+"""The number of characters from the git SHA to include in pre-release tags."""
+
+
+def compute_prerelease_docker_image_tag(base_version: str, sha: str) -> str:
+    """Compute the pre-release docker image tag.
+
+    This is the SINGLE SOURCE OF TRUTH for pre-release version format.
+    All other code should receive this value as a parameter, not recompute it.
+
+    The format is: {base_version}-preview.{short_sha}
+
+    Where:
+        - base_version: The base version from metadata.yaml (e.g., "1.2.3")
+        - short_sha: The first 7 characters of the git commit SHA
+
+    Examples:
+        >>> compute_prerelease_docker_image_tag("1.2.3", "abcdef1234567890")
+        '1.2.3-preview.abcdef1'
+        >>> compute_prerelease_docker_image_tag("0.1.0", "1234567")
+        '0.1.0-preview.1234567'
+
+    Args:
+        base_version: The base version from metadata.yaml (e.g., "1.2.3")
+        sha: The full git commit SHA (or at least 7 characters)
+
+    Returns:
+        Pre-release version tag (e.g., "1.2.3-preview.abcde12")
+    """
+    short_sha = sha[:PRERELEASE_SHA_LENGTH]
+    return f"{base_version}-{PRERELEASE_TAG_PREFIX}.{short_sha}"
+
 
 class PRHeadInfo(BaseModel):
     """Information about a PR's head commit."""
@@ -268,7 +307,9 @@ def publish_connector_to_airbyte_registry(
         docker_image = data.get("dockerRepository")
         base_version = data.get("dockerImageTag")
         if base_version:
-            docker_image_tag = f"{base_version}-preview.{head_info.short_sha}"
+            docker_image_tag = compute_prerelease_docker_image_tag(
+                base_version, head_info.sha
+            )
 
     return PrereleaseWorkflowResult(
         success=True,

{airbyte_internal_ops-0.2.2 → airbyte_internal_ops-0.2.3}/tests/test_cli_registry.py

@@ -112,6 +112,59 @@ def test_cli_help() -> None:
     assert "registry" in result.stdout
 
 
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "base_version,sha,expected",
+    [
+        pytest.param(
+            "1.2.3", "abcdef1234567890", "1.2.3-preview.abcdef1", id="standard"
+        ),
+        pytest.param("0.1.0", "1234567", "0.1.0-preview.1234567", id="short_sha"),
+        pytest.param("0.6.0", "a6370d9275", "0.6.0-preview.a6370d9", id="real_world"),
+    ],
+)
+def test_registry_connector_compute_prerelease_tag_with_base_version(
+    base_version: str, sha: str, expected: str
+) -> None:
+    """Test compute-prerelease-tag CLI command with explicit base-version."""
+    result = run_cli(
+        "registry",
+        "connector",
+        "compute-prerelease-tag",
+        "--connector-name",
+        "source-test",  # Connector name is required but not used when base-version is provided
+        "--sha",
+        sha,
+        "--base-version",
+        base_version,
+    )
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+
+
+@pytest.mark.unit
+def test_registry_connector_compute_prerelease_tag_help() -> None:
+    """Test compute-prerelease-tag help output."""
+    result = run_cli("registry", "connector", "compute-prerelease-tag", "--help")
+    assert result.returncode == 0
+    assert "connector-name" in result.stdout
+    assert "sha" in result.stdout
+    assert "base-version" in result.stdout
+
+
+@pytest.mark.unit
+def test_registry_connector_compute_prerelease_tag_missing_connector_name() -> None:
+    """Test compute-prerelease-tag fails without connector-name."""
+    result = run_cli(
+        "registry",
+        "connector",
+        "compute-prerelease-tag",
+        "--sha",
+        "abcdef1",
+    )
+    assert result.returncode != 0
+
+
 @pytest.mark.unit
 def test_registry_help() -> None:
     """Test registry subcommand help output."""

airbyte_internal_ops-0.2.3/tests/test_prerelease.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""Tests for the prerelease module."""
+
+import pytest
+
+from airbyte_ops_mcp.mcp.prerelease import (
+    PRERELEASE_SHA_LENGTH,
+    PRERELEASE_TAG_PREFIX,
+    compute_prerelease_docker_image_tag,
+)
+
+
+@pytest.mark.parametrize(
+    "base_version,sha,expected",
+    [
+        pytest.param(
+            "1.2.3",
+            "abcdef1234567890",
+            "1.2.3-preview.abcdef1",
+            id="standard_version_long_sha",
+        ),
+        pytest.param(
+            "0.1.0",
+            "1234567",
+            "0.1.0-preview.1234567",
+            id="short_version_exact_sha_length",
+        ),
+        pytest.param(
+            "10.20.30",
+            "abc1234",
+            "10.20.30-preview.abc1234",
+            id="large_version_numbers",
+        ),
+        pytest.param(
+            "0.0.1",
+            "deadbeef12345678901234567890",
+            "0.0.1-preview.deadbee",
+            id="very_long_sha_truncated",
+        ),
+        pytest.param(
+            "2.0.0",
+            "a6370d9275abc123",
+            "2.0.0-preview.a6370d9",
+            id="real_world_sha_example",
+        ),
+    ],
+)
+def test_compute_prerelease_docker_image_tag(
+    base_version: str, sha: str, expected: str
+) -> None:
+    """Test that compute_prerelease_docker_image_tag produces correct version tags."""
+    result = compute_prerelease_docker_image_tag(base_version, sha)
+    assert result == expected
+
+
+def test_prerelease_constants() -> None:
+    """Test that prerelease constants have expected values."""
+    assert PRERELEASE_TAG_PREFIX == "preview"
+    assert PRERELEASE_SHA_LENGTH == 7
+
+
+def test_compute_prerelease_docker_image_tag_uses_constants() -> None:
+    """Test that the function uses the defined constants for consistency."""
+    base_version = "1.0.0"
+    sha = "abcdefghijklmnop"
+
+    result = compute_prerelease_docker_image_tag(base_version, sha)
+
+    assert f"-{PRERELEASE_TAG_PREFIX}." in result
+    assert result.endswith(sha[:PRERELEASE_SHA_LENGTH])