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)

102@dataclass
103class CompileResult:
104    """Result of a registry compile operation."""
105
106    target: str
107    connectors_scanned: int = 0
108    versions_found: int = 0
109    yanked_versions: int = 0
110    latest_updated: int = 0
111    latest_already_current: int = 0
112    cloud_registry_entries: int = 0
113    oss_registry_entries: int = 0
114    composite_registry_entries: int = 0
115    metrics_connector_count: int = 0
116    metrics_registry_entries: int = 0
117    metrics_source: str | None = None
118    metrics_error: str | None = None
119    version_indexes_written: int = 0
120    specs_secrets_mask_properties: int = 0
121    errors: list[str] = field(default_factory=list)
122    dry_run: bool = False
123
124    @property
125    def status(self) -> str:
126        if self.dry_run:
127            return "dry-run"
128        if self.errors:
129            return "completed-with-errors"
130        return "success"
131
132    def summary(self) -> str:
133        return (
134            f"[{self.status}] Scanned {self.connectors_scanned} connectors, "
135            f"{self.versions_found} versions ({self.yanked_versions} yanked). "
136            f"Latest updated: {self.latest_updated}, "
137            f"already current: {self.latest_already_current}. "
138            f"Registry entries: cloud={self.cloud_registry_entries}, "
139            f"oss={self.oss_registry_entries}, "
140            f"composite={self.composite_registry_entries}. "
141            f"Metrics loaded for {self.metrics_connector_count} connectors, "
142            f"injected into {self.metrics_registry_entries} registry entries. "
143            f"Version indexes: {self.version_indexes_written}. "
144            f"Specs secrets mask: {self.specs_secrets_mask_properties} properties. "
145            f"Errors: {len(self.errors)}."
146        )

 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

127@dataclass
128class GenerateResult:
129    """Result of a local artifact generation run."""
130
131    connector_name: str
132    version: str
133    docker_image: str
134    output_dir: str
135    artifacts_written: list[str] = field(default_factory=list)
136    errors: list[str] = field(default_factory=list)
137    validation_errors: list[str] = field(default_factory=list)
138    dry_run: bool = False
139
140    @property
141    def success(self) -> bool:
142        return len(self.errors) == 0 and len(self.validation_errors) == 0
143
144    def to_dict(self) -> dict[str, Any]:
145        return {
146            "connector_name": self.connector_name,
147            "version": self.version,
148            "docker_image": self.docker_image,
149            "output_dir": self.output_dir,
150            "artifacts_written": self.artifacts_written,
151            "errors": self.errors,
152            "validation_errors": self.validation_errors,
153            "dry_run": self.dry_run,
154            "success": self.success,
155        }

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"

149@dataclass
150class PurgeLatestResult:
151    """Result of a purge-latest operation."""
152
153    target: str
154    connectors_found: int = 0
155    latest_dirs_deleted: int = 0
156    errors: list[str] = field(default_factory=list)
157    dry_run: bool = False
158
159    @property
160    def status(self) -> str:
161        if self.dry_run:
162            return "dry-run"
163        if self.errors:
164            return "completed-with-errors"
165        return "success"
166
167    def summary(self) -> str:
168        return (
169            f"[{self.status}] Found {self.connectors_found} connectors, "
170            f"deleted {self.latest_dirs_deleted} latest/ directories. "
171            f"Errors: {len(self.errors)}."
172        )

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        with_metrics: bool = True,
169        force: bool = False,
170    ) -> CompileResult:
171        raise NotImplementedError(
172            _op_not_implemented_message(self.store_type, "compile")
173        )
174
175    def marketing_stubs_check(self, repo_root: Path) -> dict[str, Any]:
176        raise NotImplementedError(
177            _op_not_implemented_message(self.store_type, "marketing_stubs_check")
178        )
179
180    def marketing_stubs_sync(
181        self,
182        repo_root: Path,
183        dry_run: bool = False,
184    ) -> dict[str, Any]:
185        raise NotImplementedError(
186            _op_not_implemented_message(self.store_type, "marketing_stubs_sync")
187        )
188
189    def mirror(
190        self,
191        output_mode: OutputMode,
192        output_path_root: str | None = None,
193        gcs_bucket: str | None = None,
194        s3_bucket: str | None = None,
195        dry_run: bool = False,
196        connector_name: list[str] | None = None,
197    ) -> RebuildResult:
198        raise NotImplementedError(
199            _op_not_implemented_message(self.store_type, "mirror")
200        )