airbyte_ops_mcp.registry

37@dataclass
38class AuditResult:
39    """Result of auditing which connectors have unpublished versions."""
40
41    unpublished: list[UnpublishedConnector] = field(default_factory=list)
42    checked_count: int = 0
43    skipped_archived: list[str] = field(default_factory=list)
44    skipped_rc: list[str] = field(default_factory=list)
45    skipped_disabled: list[str] = field(default_factory=list)
46    errors: list[str] = field(default_factory=list)

 93@dataclass
 94class CompileResult:
 95    """Result of a registry compile operation."""
 96
 97    target: str
 98    connectors_scanned: int = 0
 99    versions_found: int = 0
100    yanked_versions: int = 0
101    latest_updated: int = 0
102    latest_already_current: int = 0
103    cloud_registry_entries: int = 0
104    oss_registry_entries: int = 0
105    composite_registry_entries: int = 0
106    version_indexes_written: int = 0
107    specs_secrets_mask_properties: int = 0
108    errors: list[str] = field(default_factory=list)
109    dry_run: bool = False
110
111    @property
112    def status(self) -> str:
113        if self.dry_run:
114            return "dry-run"
115        if self.errors:
116            return "completed-with-errors"
117        return "success"
118
119    def summary(self) -> str:
120        return (
121            f"[{self.status}] Scanned {self.connectors_scanned} connectors, "
122            f"{self.versions_found} versions ({self.yanked_versions} yanked). "
123            f"Latest updated: {self.latest_updated}, "
124            f"already current: {self.latest_already_current}. "
125            f"Registry entries: cloud={self.cloud_registry_entries}, "
126            f"oss={self.oss_registry_entries}, "
127            f"composite={self.composite_registry_entries}. "
128            f"Version indexes: {self.version_indexes_written}. "
129            f"Specs secrets mask: {self.specs_secrets_mask_properties} properties. "
130            f"Errors: {len(self.errors)}."
131        )

 88class ConnectorLanguage(StrEnum):
 89    """Connector implementation languages."""
 90
 91    PYTHON = "python"
 92    JAVA = "java"
 93    LOW_CODE = "low-code"
 94    MANIFEST_ONLY = "manifest-only"
 95
 96    @classmethod
 97    def parse(cls, value: str) -> ConnectorLanguage:
 98        """Parse a string into a `ConnectorLanguage`, raising `ValueError` on mismatch."""
 99        try:
100            return cls(value)
101        except ValueError:
102            valid = ", ".join(f"`{m.value}`" for m in cls)
103            raise ValueError(
104                f"Unrecognized language: {value!r}. Expected one of: {valid}."
105            ) from None

106class ConnectorListResult(BaseModel):
107    """Result of listing connectors in the registry."""
108
109    bucket_name: str = Field(description="The GCS bucket name")
110    connector_count: int = Field(description="Number of connectors found")
111    connectors: list[str] = Field(description="List of connector names")

16class ConnectorMetadata(BaseModel):
17    """Connector metadata from metadata.yaml.
18
19    This model represents the essential metadata about a connector
20    read from its metadata.yaml file in the Airbyte monorepo.
21    """
22
23    name: str = Field(description="The connector technical name")
24    docker_repository: str = Field(description="The Docker repository")
25    docker_image_tag: str = Field(description="The Docker image tag/version")
26    support_level: str | None = Field(
27        default=None, description="The support level (certified, community, etc.)"
28    )
29    definition_id: str | None = Field(
30        default=None, description="The connector definition ID"
31    )

34class ConnectorPublishResult(BaseModel):
35    """Result of a connector publish operation.
36
37    This model provides detailed information about the outcome of a
38    connector publish operation (apply or rollback version override).
39    """
40
41    connector: str = Field(description="The connector technical name")
42    version: str = Field(description="The connector version")
43    action: Literal["progressive-rollout-create", "progressive-rollout-cleanup"] = (
44        Field(description="The action performed")
45    )
46    status: Literal["success", "failure", "dry-run"] = Field(
47        description="The status of the operation"
48    )
49    docker_image: str | None = Field(
50        default=None, description="The Docker image name if applicable"
51    )
52    registry_updated: bool = Field(
53        default=False, description="Whether the registry was updated"
54    )
55    message: str | None = Field(default=None, description="Additional status message")
56
57    def __str__(self) -> str:
58        """Return a string representation of the publish result."""
59        status_prefix = "dry-run" if self.status == "dry-run" else self.status
60        return f"[{status_prefix}] {self.connector}:{self.version} - {self.action}"

70class ConnectorType(StrEnum):
71    """Connector type: source or destination."""
72
73    SOURCE = "source"
74    DESTINATION = "destination"
75
76    @classmethod
77    def parse(cls, value: str) -> ConnectorType:
78        """Parse a string into a `ConnectorType`, raising `ValueError` on mismatch."""
79        try:
80            return cls(value)
81        except ValueError:
82            valid = ", ".join(f"`{m.value}`" for m in cls)
83            raise ValueError(
84                f"Unrecognized connector type: {value!r}. Expected one of: {valid}."
85            ) from None

100@dataclass
101class GenerateResult:
102    """Result of a local artifact generation run."""
103
104    connector_name: str
105    version: str
106    docker_image: str
107    output_dir: str
108    artifacts_written: list[str] = field(default_factory=list)
109    errors: list[str] = field(default_factory=list)
110    validation_errors: list[str] = field(default_factory=list)
111    dry_run: bool = False
112
113    @property
114    def success(self) -> bool:
115        return len(self.errors) == 0 and len(self.validation_errors) == 0
116
117    def to_dict(self) -> dict[str, Any]:
118        return {
119            "connector_name": self.connector_name,
120            "version": self.version,
121            "docker_image": self.docker_image,
122            "output_dir": self.output_dir,
123            "artifacts_written": self.artifacts_written,
124            "errors": self.errors,
125            "validation_errors": self.validation_errors,
126            "dry_run": self.dry_run,
127            "success": self.success,
128        }

63class MetadataPublishResult(BaseModel):
64    """Result of a metadata publish operation to GCS.
65
66    This model provides detailed information about the outcome of
67    publishing connector metadata to the registry.
68    """
69
70    connector_name: str = Field(description="The connector technical name")
71    version: str = Field(description="The version that was published")
72    bucket_name: str = Field(description="The GCS bucket name")
73    versioned_path: str = Field(description="The versioned GCS path")
74    latest_path: str | None = Field(
75        default=None, description="The latest GCS path if updated"
76    )
77    versioned_uploaded: bool = Field(
78        default=False, description="Whether the versioned metadata was uploaded"
79    )
80    latest_uploaded: bool = Field(
81        default=False, description="Whether the latest metadata was uploaded"
82    )
83    status: Literal["success", "dry-run", "already-up-to-date"] = Field(
84        description="The status of the operation"
85    )
86    message: str = Field(description="Status message describing the outcome")
87
88    def __str__(self) -> str:
89        """Return a string representation of the publish result."""
90        return f"[{self.status}] {self.connector_name}:{self.version} -> {self.versioned_path}"

46@dataclass
47class PublishArtifactsResult:
48    """Result of a version-artifacts publish operation."""
49
50    connector_name: str
51    version: str
52    target: str
53    gcs_destination: str
54    files_uploaded: list[str] = field(default_factory=list)
55    errors: list[str] = field(default_factory=list)
56    validation_errors: list[str] = field(default_factory=list)
57    dry_run: bool = False
58
59    @property
60    def success(self) -> bool:
61        return len(self.errors) == 0 and len(self.validation_errors) == 0
62
63    @property
64    def status(self) -> str:
65        if self.dry_run:
66            return "dry-run"
67        if self.errors or self.validation_errors:
68            return "completed-with-errors"
69        return "success"

134@dataclass
135class PurgeLatestResult:
136    """Result of a purge-latest operation."""
137
138    target: str
139    connectors_found: int = 0
140    latest_dirs_deleted: int = 0
141    errors: list[str] = field(default_factory=list)
142    dry_run: bool = False
143
144    @property
145    def status(self) -> str:
146        if self.dry_run:
147            return "dry-run"
148        if self.errors:
149            return "completed-with-errors"
150        return "success"
151
152    def summary(self) -> str:
153        return (
154            f"[{self.status}] Found {self.connectors_found} connectors, "
155            f"deleted {self.latest_dirs_deleted} latest/ directories. "
156            f"Errors: {len(self.errors)}."
157        )

43@dataclass
44class RebuildResult:
45    """Result of a registry rebuild operation."""
46
47    source_bucket: str
48    output_mode: OutputMode
49    output_root: str
50    connectors_processed: int = 0
51    blobs_copied: int = 0
52    blobs_skipped: int = 0
53    errors: list[str] = field(default_factory=list)
54    dry_run: bool = False
55
56    @property
57    def status(self) -> str:
58        """Return the status of the rebuild operation."""
59        if self.dry_run:
60            return "dry-run"
61        if self.errors:
62            return "completed-with-errors"
63        return "success"
64
65    def summary(self) -> str:
66        """Return a human-readable summary."""
67        return (
68            f"[{self.status}] Rebuilt {self.connectors_processed} connectors, "
69            f"{self.blobs_copied} blobs copied, {self.blobs_skipped} skipped, "
70            f"{len(self.errors)} errors. Output: {self.output_root}"
71        )

 38class Registry(ABC):
 39    """A configured connector registry store.
 40
 41    A Registry is bound to a specific `airbyte_ops_mcp.registry.store.RegistryStore`
 42    (store type + env + optional prefix), and provides methods used by the CLI to
 43    read/write registry contents.
 44    """
 45
 46    def __init__(self, store: RegistryStore) -> None:
 47        self.store = store
 48
 49    @property
 50    def store_type(self) -> StoreType:
 51        return self.store.store_type
 52
 53    @property
 54    def bucket_name(self) -> str:
 55        return self.store.bucket
 56
 57    @property
 58    def prefix(self) -> str:
 59        return self.store.prefix
 60
 61    def _require_no_prefix(self, op_name: str) -> None:
 62        """Raise if this op doesn't support prefixed targets."""
 63
 64        if self.prefix:
 65            raise NotImplementedError(
 66                f"Operation '{op_name}' does not yet support store prefixes (got prefix='{self.prefix}')."
 67            )
 68
 69    # ---------------------------------------------------------------------
 70    # Read operations
 71    # ---------------------------------------------------------------------
 72
 73    @abstractmethod
 74    def list_connectors(
 75        self,
 76        *,
 77        support_level: SupportLevel | None = None,
 78        min_support_level: SupportLevel | None = None,
 79        connector_type: ConnectorType | None = None,
 80        language: ConnectorLanguage | None = None,
 81    ) -> list[str]:
 82        raise NotImplementedError(
 83            _op_not_implemented_message(self.store_type, "list_connectors")
 84        )
 85
 86    def list_connector_versions(self, connector_name: str) -> list[str]:
 87        raise NotImplementedError(
 88            _op_not_implemented_message(self.store_type, "list_connector_versions")
 89        )
 90
 91    def get_connector_metadata(
 92        self, connector_name: str, version: str = "latest"
 93    ) -> dict[str, Any]:
 94        raise NotImplementedError(
 95            _op_not_implemented_message(self.store_type, "get_connector_metadata")
 96        )
 97
 98    # ---------------------------------------------------------------------
 99    # Write / mutate operations
100    # ---------------------------------------------------------------------
101
102    def progressive_rollout_create(
103        self,
104        repo_path: Path,
105        connector_name: str,
106        dry_run: bool = False,
107    ) -> ConnectorPublishResult:
108        raise NotImplementedError(
109            _op_not_implemented_message(self.store_type, "progressive_rollout_create")
110        )
111
112    def progressive_rollout_cleanup(
113        self,
114        repo_path: Path,
115        connector_name: str,
116        dry_run: bool = False,
117    ) -> ConnectorPublishResult:
118        raise NotImplementedError(
119            _op_not_implemented_message(self.store_type, "progressive_rollout_cleanup")
120        )
121
122    def yank(
123        self,
124        connector_name: str,
125        version: str,
126        reason: str = "",
127        dry_run: bool = False,
128    ) -> YankResult:
129        raise NotImplementedError(_op_not_implemented_message(self.store_type, "yank"))
130
131    def unyank(
132        self,
133        connector_name: str,
134        version: str,
135        dry_run: bool = False,
136    ) -> YankResult:
137        raise NotImplementedError(
138            _op_not_implemented_message(self.store_type, "unyank")
139        )
140
141    def publish_version_artifacts(
142        self,
143        connector_name: str,
144        version: str,
145        artifacts_dir: Path,
146        dry_run: bool = False,
147        with_validate: bool = True,
148    ) -> PublishArtifactsResult:
149        raise NotImplementedError(
150            _op_not_implemented_message(self.store_type, "publish_version_artifacts")
151        )
152
153    def delete_dev_latest(
154        self,
155        connector_name: list[str] | None = None,
156        dry_run: bool = False,
157    ) -> PurgeLatestResult:
158        raise NotImplementedError(
159            _op_not_implemented_message(self.store_type, "delete_dev_latest")
160        )
161
162    def compile(
163        self,
164        connector_name: list[str] | None = None,
165        dry_run: bool = False,
166        with_secrets_mask: bool = False,
167        with_legacy_migration: str | None = None,
168        force: bool = False,
169    ) -> CompileResult:
170        raise NotImplementedError(
171            _op_not_implemented_message(self.store_type, "compile")
172        )
173
174    def marketing_stubs_check(self, repo_root: Path) -> dict[str, Any]:
175        raise NotImplementedError(
176            _op_not_implemented_message(self.store_type, "marketing_stubs_check")
177        )
178
179    def marketing_stubs_sync(
180        self,
181        repo_root: Path,
182        dry_run: bool = False,
183    ) -> dict[str, Any]:
184        raise NotImplementedError(
185            _op_not_implemented_message(self.store_type, "marketing_stubs_sync")
186        )
187
188    def mirror(
189        self,
190        output_mode: OutputMode,
191        output_path_root: str | None = None,
192        gcs_bucket: str | None = None,
193        s3_bucket: str | None = None,
194        dry_run: bool = False,
195        connector_name: list[str] | None = None,
196    ) -> RebuildResult:
197        raise NotImplementedError(
198            _op_not_implemented_message(self.store_type, "mirror")
199        )

 93class RegistryEntryResult(BaseModel):
 94    """Result of reading a registry entry from GCS.
 95
 96    This model wraps the raw metadata dictionary with additional context.
 97    """
 98
 99    connector_name: str = Field(description="The connector technical name")
100    version: str = Field(description="The version that was read")
101    bucket_name: str = Field(description="The GCS bucket name")
102    gcs_path: str = Field(description="The GCS path that was read")
103    metadata: dict = Field(description="The raw metadata dictionary")