airbyte-internal-ops 0.4.0__tar.gz → 0.4.1__tar.gz

{airbyte_internal_ops-0.4.0 → airbyte_internal_ops-0.4.1}/.github/workflows/connector-regression-test.yml

@@ -104,7 +104,7 @@ on:
 
 jobs:
   regression-test:
-    name: Regression Test: '${{ inputs.connector_name }}'
+    name: "Regression Test: '${{ inputs.connector_name }}'"
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code

{airbyte_internal_ops-0.4.0 → airbyte_internal_ops-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.4.0
+Version: 0.4.1
 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.4.0 → airbyte_internal_ops-0.4.1}/bin/test_mcp_tool.py

@@ -8,7 +8,7 @@ Usage:
 Examples:
     poe mcp-tool-test publish_connector_to_airbyte_registry \
         '{"connector_name": "destination-pinecone", "pr_number": 70202}'
-    poe mcp-tool-test check_workflow_status \
+    poe mcp-tool-test check_ci_workflow_status \
         '{"workflow_url": "https://github.com/airbytehq/airbyte/actions/runs/12345"}'
     poe mcp-tool-test get_docker_image_info \
         '{"image": "airbyte/destination-pinecone", "tag": "0.1.0-preview.abc1234"}'

airbyte_internal_ops-0.4.1/src/airbyte_ops_mcp/cli/gh.py

@@ -0,0 +1,174 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""CLI commands for GitHub operations.
+
+Commands:
+    airbyte-ops gh workflow status - Check GitHub Actions workflow status
+    airbyte-ops gh workflow trigger - Trigger a GitHub Actions CI workflow
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Annotated
+
+from cyclopts import App, Parameter
+
+from airbyte_ops_mcp.cli._base import app
+from airbyte_ops_mcp.cli._shared import exit_with_error, print_json
+from airbyte_ops_mcp.mcp.github_actions import (
+    check_ci_workflow_status,
+    trigger_ci_workflow,
+)
+
+# Create the gh sub-app
+gh_app = App(name="gh", help="GitHub operations.")
+app.command(gh_app)
+
+# Create the workflow sub-app under gh
+workflow_app = App(name="workflow", help="GitHub Actions workflow operations.")
+gh_app.command(workflow_app)
+
+
+@workflow_app.command(name="status")
+def workflow_status(
+    url: Annotated[
+        str | None,
+        Parameter(
+            help="Full GitHub Actions workflow run URL "
+            "(e.g., 'https://github.com/owner/repo/actions/runs/12345')."
+        ),
+    ] = None,
+    owner: Annotated[
+        str | None,
+        Parameter(help="Repository owner (e.g., 'airbytehq')."),
+    ] = None,
+    repo: Annotated[
+        str | None,
+        Parameter(help="Repository name (e.g., 'airbyte')."),
+    ] = None,
+    run_id: Annotated[
+        int | None,
+        Parameter(help="Workflow run ID."),
+    ] = None,
+) -> None:
+    """Check the status of a GitHub Actions workflow run.
+
+    Provide either --url OR all of (--owner, --repo, --run-id).
+    """
+    # Validate input parameters
+    if url:
+        if owner or repo or run_id:
+            exit_with_error(
+                "Cannot specify --url together with --owner/--repo/--run-id. "
+                "Use either --url OR the component parts."
+            )
+    elif not (owner and repo and run_id):
+        exit_with_error(
+            "Must provide either --url OR all of (--owner, --repo, --run-id)."
+        )
+
+    result = check_ci_workflow_status(
+        workflow_url=url,
+        owner=owner,
+        repo=repo,
+        run_id=run_id,
+    )
+    print_json(result.model_dump())
+
+
+@workflow_app.command(name="trigger")
+def workflow_trigger(
+    owner: Annotated[
+        str,
+        Parameter(help="Repository owner (e.g., 'airbytehq')."),
+    ],
+    repo: Annotated[
+        str,
+        Parameter(help="Repository name (e.g., 'airbyte')."),
+    ],
+    workflow_file: Annotated[
+        str,
+        Parameter(help="Workflow file name (e.g., 'connector-regression-test.yml')."),
+    ],
+    workflow_definition_ref: Annotated[
+        str | None,
+        Parameter(
+            help="Branch name or PR number for the workflow definition to use. "
+            "If a PR number is provided, it resolves to the PR's head branch name. "
+            "Defaults to 'main' if not specified."
+        ),
+    ] = None,
+    inputs: Annotated[
+        str | None,
+        Parameter(
+            help='Workflow inputs as a JSON string (e.g., \'{"key": "value"}\').'
+        ),
+    ] = None,
+    wait: Annotated[
+        bool,
+        Parameter(help="Wait for the workflow to complete before returning."),
+    ] = False,
+    wait_seconds: Annotated[
+        int,
+        Parameter(
+            help="Maximum seconds to wait for workflow completion (default: 600)."
+        ),
+    ] = 600,
+) -> None:
+    """Trigger a GitHub Actions CI workflow via workflow_dispatch.
+
+    This command triggers a workflow in any GitHub repository that has workflow_dispatch
+    enabled. It resolves PR numbers to branch names automatically.
+    """
+    # Parse inputs JSON if provided
+    parsed_inputs: dict[str, str] | None = None
+    if inputs:
+        try:
+            parsed_inputs = json.loads(inputs)
+        except json.JSONDecodeError as e:
+            exit_with_error(f"Invalid JSON for --inputs: {e}")
+
+    # Trigger the workflow
+    result = trigger_ci_workflow(
+        owner=owner,
+        repo=repo,
+        workflow_file=workflow_file,
+        workflow_definition_ref=workflow_definition_ref,
+        inputs=parsed_inputs,
+    )
+
+    print_json(result.model_dump())
+
+    # If wait is enabled and we have a run_id, poll for completion
+    if wait and result.run_id:
+        print(f"\nWaiting for workflow to complete (timeout: {wait_seconds}s)...")
+        start_time = time.time()
+        poll_interval = 10  # seconds
+
+        while time.time() - start_time < wait_seconds:
+            status_result = check_ci_workflow_status(
+                owner=owner,
+                repo=repo,
+                run_id=result.run_id,
+            )
+
+            if status_result.status == "completed":
+                print(
+                    f"\nWorkflow completed with conclusion: {status_result.conclusion}"
+                )
+                print_json(status_result.model_dump())
+                return
+
+            elapsed = int(time.time() - start_time)
+            print(f"  Status: {status_result.status} (elapsed: {elapsed}s)")
+            time.sleep(poll_interval)
+
+        print(f"\nTimeout reached after {wait_seconds}s. Workflow still running.")
+        # Print final status
+        final_status = check_ci_workflow_status(
+            owner=owner,
+            repo=repo,
+            run_id=result.run_id,
+        )
+        print_json(final_status.model_dump())

{airbyte_internal_ops-0.4.0 → airbyte_internal_ops-0.4.1}/src/airbyte_ops_mcp/cli/registry.py

@@ -28,11 +28,11 @@ from airbyte_ops_mcp.cli._shared import (
     print_json,
     print_success,
 )
-from airbyte_ops_mcp.github_actions import (
+from airbyte_ops_mcp.github_api 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.github_actions import get_docker_image_info
 from airbyte_ops_mcp.mcp.prerelease import (
     compute_prerelease_docker_image_tag,
     publish_connector_to_airbyte_registry,

{airbyte_internal_ops-0.4.0 → airbyte_internal_ops-0.4.1}/src/airbyte_ops_mcp/github_actions.py

@@ -1,72 +1,23 @@
 # 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
+This module provides utilities for interacting with GitHub Actions workflows,
+including workflow dispatch, run discovery, and job status. These utilities
 are used by MCP tools but are not MCP-specific.
+
+For general GitHub API utilities (authentication, PR info, file contents),
+see the github_api module.
 """
 
 from __future__ import annotations
 
-import os
-import shutil
-import subprocess
 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 or gh CLI.
-
-    Checks environment variables in order of preference, returning the first
-    non-empty value found. If no environment variables are set, attempts to
-    get a token from the gh CLI tool using 'gh auth token'.
-
-    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 env vars or gh CLI.
-    """
-    if preferred_env_vars is None:
-        preferred_env_vars = ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"]
-
-    # Check environment variables first
-    for env_var in preferred_env_vars:
-        token = os.getenv(env_var)
-        if token:
-            return token
-
-    # Fall back to gh CLI if available
-    gh_path = shutil.which("gh")
-    if gh_path:
-        try:
-            result = subprocess.run(
-                [gh_path, "auth", "token"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-                check=False,
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                return result.stdout.strip()
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
-            pass
-
-    env_var_list = ", ".join(preferred_env_vars)
-    raise ValueError(
-        f"No GitHub token found. Set one of: {env_var_list} environment variable, "
-        "or authenticate with 'gh auth login'."
-    )
+from airbyte_ops_mcp.github_api import GITHUB_API_BASE, resolve_github_token
 
 
 @dataclass
@@ -106,51 +57,6 @@ 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.4.0 → airbyte_internal_ops-0.4.1}/src/airbyte_ops_mcp/github_api.py

@@ -1,20 +1,178 @@
 # Copyright (c) 2025 Airbyte, Inc., all rights reserved.
-"""GitHub API utilities for user and comment operations.
+"""GitHub API utilities.
 
-This module provides utilities for interacting with GitHub's REST API
-to retrieve user information and comment details. These utilities are
-used by MCP tools for authorization and audit purposes.
+This module provides core utilities for interacting with GitHub's REST API,
+including authentication, user/comment operations, PR information retrieval,
+and file content fetching. These utilities are used by MCP tools and other
+modules but are not MCP-specific.
 """
 
 from __future__ import annotations
 
+import os
 import re
+import shutil
+import subprocess
 from dataclasses import dataclass
 from urllib.parse import urlparse
 
 import requests
 
-from airbyte_ops_mcp.github_actions import GITHUB_API_BASE, resolve_github_token
+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 or gh CLI.
+
+    Checks environment variables in order of preference, returning the first
+    non-empty value found. If no environment variables are set, attempts to
+    get a token from the gh CLI tool using 'gh auth token'.
+
+    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 env vars or gh CLI.
+    """
+    if preferred_env_vars is None:
+        preferred_env_vars = ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"]
+
+    # Check environment variables first
+    for env_var in preferred_env_vars:
+        token = os.getenv(env_var)
+        if token:
+            return token
+
+    # Fall back to gh CLI if available
+    gh_path = shutil.which("gh")
+    if gh_path:
+        try:
+            result = subprocess.run(
+                [gh_path, "auth", "token"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            pass
+
+    env_var_list = ", ".join(preferred_env_vars)
+    raise ValueError(
+        f"No GitHub token found. Set one of: {env_var_list} environment variable, "
+        "or authenticate with 'gh auth login'."
+    )
+
+
+@dataclass
+class PRHeadInfo:
+    """Information about a PR's head commit."""
+
+    ref: str
+    """Branch name of the PR's head"""
+
+    sha: str
+    """Full commit SHA of the PR's head"""
+
+    short_sha: str
+    """First 7 characters of the commit SHA"""
+
+
+def get_pr_head_ref(
+    owner: str,
+    repo: str,
+    pr_number: int,
+    token: str,
+) -> PRHeadInfo:
+    """Get the head ref (branch name) and SHA for a PR.
+
+    This is useful for resolving a PR number to the actual branch name,
+    which is required for workflow_dispatch API calls (which don't accept
+    refs/pull/{pr}/head format).
+
+    Args:
+        owner: Repository owner (e.g., "airbytehq")
+        repo: Repository name (e.g., "airbyte")
+        pr_number: Pull request number
+        token: GitHub API token
+
+    Returns:
+        PRHeadInfo with ref (branch name), sha, and short_sha.
+
+    Raises:
+        ValueError: If PR not found.
+        requests.HTTPError: If API request fails.
+    """
+    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/pulls/{pr_number}"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+
+    response = requests.get(url, headers=headers, timeout=30)
+    if response.status_code == 404:
+        raise ValueError(f"PR {owner}/{repo}#{pr_number} not found")
+    response.raise_for_status()
+
+    pr_data = response.json()
+    sha = pr_data["head"]["sha"]
+    return PRHeadInfo(
+        ref=pr_data["head"]["ref"],
+        sha=sha,
+        short_sha=sha[:7],
+    )
+
+
+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
 
 
 class GitHubCommentParseError(Exception):

airbyte_internal_ops-0.4.0/src/airbyte_ops_mcp/mcp/github.py → airbyte_internal_ops-0.4.1/src/airbyte_ops_mcp/mcp/github_actions.py

@@ -15,12 +15,22 @@ from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
 from airbyte_ops_mcp.github_actions import (
-    GITHUB_API_BASE,
     get_workflow_jobs,
+    trigger_workflow_dispatch,
+)
+from airbyte_ops_mcp.github_api import (
+    GITHUB_API_BASE,
+    get_pr_head_ref,
     resolve_github_token,
 )
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
+# Token env vars for workflow triggering (in order of preference)
+WORKFLOW_TRIGGER_TOKEN_ENV_VARS = [
+    "GITHUB_CI_WORKFLOW_TRIGGER_PAT",
+    "GITHUB_TOKEN",
+]
+
 DOCKERHUB_API_BASE = "https://hub.docker.com/v2"
 
 
@@ -36,7 +46,7 @@ class JobInfo(BaseModel):
 
 
 class WorkflowRunStatus(BaseModel):
-    """Response model for check_workflow_status MCP tool."""
+    """Response model for check_ci_workflow_status MCP tool."""
 
     run_id: int
     status: str
@@ -116,7 +126,7 @@ def _get_workflow_run(
     idempotent=True,
     open_world=True,
 )
-def check_workflow_status(
+def check_ci_workflow_status(
     workflow_url: Annotated[
         str | None,
         Field(
@@ -196,6 +206,108 @@ def check_workflow_status(
     )
 
 
+class TriggerCIWorkflowResult(BaseModel):
+    """Response model for trigger_ci_workflow MCP tool."""
+
+    success: bool
+    message: str
+    workflow_url: str
+    run_id: int | None = None
+    run_url: str | None = None
+
+
+@mcp_tool(
+    read_only=False,
+    idempotent=False,
+    open_world=True,
+)
+def trigger_ci_workflow(
+    owner: Annotated[
+        str,
+        Field(description="Repository owner (e.g., 'airbytehq')"),
+    ],
+    repo: Annotated[
+        str,
+        Field(description="Repository name (e.g., 'airbyte')"),
+    ],
+    workflow_file: Annotated[
+        str,
+        Field(description="Workflow file name (e.g., 'connector-regression-test.yml')"),
+    ],
+    workflow_definition_ref: Annotated[
+        str | None,
+        Field(
+            description="Branch name or PR number for the workflow definition to use. "
+            "If a PR number (integer string) is provided, it resolves to the PR's head branch name. "
+            "If a branch name is provided, it is used directly. "
+            "Defaults to the repository's default branch if not specified."
+        ),
+    ] = None,
+    inputs: Annotated[
+        dict[str, str] | None,
+        Field(
+            description="Workflow inputs as a dictionary of string key-value pairs. "
+            "These are passed to the workflow_dispatch event."
+        ),
+    ] = None,
+) -> TriggerCIWorkflowResult:
+    """Trigger a GitHub Actions CI workflow via workflow_dispatch.
+
+    This tool triggers a workflow in any GitHub repository that has workflow_dispatch
+    enabled. It resolves PR numbers to branch names automatically since GitHub's
+    workflow_dispatch API only accepts branch names, not refs/pull/{pr}/head format.
+
+    Requires GITHUB_CI_WORKFLOW_TRIGGER_PAT or GITHUB_TOKEN environment variable
+    with 'actions:write' permission.
+    """
+    # Guard: Check for required token
+    token = resolve_github_token(WORKFLOW_TRIGGER_TOKEN_ENV_VARS)
+
+    # Resolve workflow definition ref
+    # If a PR number is provided (integer string), resolve to the PR's head branch name
+    # Otherwise use the provided branch name or default to repo's default branch
+    if workflow_definition_ref:
+        if workflow_definition_ref.isdigit():
+            # Resolve PR number to branch name via GitHub API
+            pr_head_info = get_pr_head_ref(
+                owner,
+                repo,
+                int(workflow_definition_ref),
+                token,
+            )
+            resolved_ref = pr_head_info.ref
+        else:
+            resolved_ref = workflow_definition_ref
+    else:
+        # Default to main (most common default branch)
+        resolved_ref = "main"
+
+    # Trigger the workflow
+    result = trigger_workflow_dispatch(
+        owner=owner,
+        repo=repo,
+        workflow_file=workflow_file,
+        ref=resolved_ref,
+        inputs=inputs or {},
+        token=token,
+        find_run=True,
+    )
+
+    # Build response message
+    if result.run_id:
+        message = f"Successfully triggered workflow {workflow_file} on {owner}/{repo} (ref: {resolved_ref}). Run ID: {result.run_id}"
+    else:
+        message = f"Successfully triggered workflow {workflow_file} on {owner}/{repo} (ref: {resolved_ref}). Run ID not yet available."
+
+    return TriggerCIWorkflowResult(
+        success=True,
+        message=message,
+        workflow_url=result.workflow_url,
+        run_id=result.run_id,
+        run_url=result.run_url,
+    )
+
+
 class DockerImageInfo(BaseModel):
     """Response model for get_docker_image_info MCP tool."""
 
@@ -282,8 +394,8 @@ def get_docker_image_info(
     )
 
 
-def register_github_tools(app: FastMCP) -> None:
-    """Register GitHub tools with the FastMCP app.
+def register_github_actions_tools(app: FastMCP) -> None:
+    """Register GitHub Actions tools with the FastMCP app.
 
     Args:
         app: FastMCP application instance