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)

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

 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

73class ConnectorListResult(BaseModel):
74    """Result of listing connectors in the registry."""
75
76    bucket_name: str = Field(description="The GCS bucket name")
77    connector_count: int = Field(description="Number of connectors found")
78    connectors: list[str] = Field(description="List of connector names")

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

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        }

30class MetadataPublishResult(BaseModel):
31    """Result of a metadata publish operation to GCS.
32
33    This model provides detailed information about the outcome of
34    publishing connector metadata to the registry.
35    """
36
37    connector_name: str = Field(description="The connector technical name")
38    version: str = Field(description="The version that was published")
39    bucket_name: str = Field(description="The GCS bucket name")
40    versioned_path: str = Field(description="The versioned GCS path")
41    latest_path: str | None = Field(
42        default=None, description="The latest GCS path if updated"
43    )
44    versioned_uploaded: bool = Field(
45        default=False, description="Whether the versioned metadata was uploaded"
46    )
47    latest_uploaded: bool = Field(
48        default=False, description="Whether the latest metadata was uploaded"
49    )
50    status: Literal["success", "dry-run", "already-up-to-date"] = Field(
51        description="The status of the operation"
52    )
53    message: str = Field(description="Status message describing the outcome")
54
55    def __str__(self) -> str:
56        """Return a string representation of the publish result."""
57        return f"[{self.status}] {self.connector_name}:{self.version} -> {self.versioned_path}"

55@dataclass
56class PublishArtifactsResult:
57    """Result of a version-artifacts publish operation."""
58
59    connector_name: str
60    version: str
61    target: str
62    gcs_destination: str
63    files_uploaded: list[str] = field(default_factory=list)
64    errors: list[str] = field(default_factory=list)
65    validation_errors: list[str] = field(default_factory=list)
66    progressive_rollout_overridden_by_breaking_change: bool = False
67    progressive_rollout_overridden_by_published_ga: bool = False
68    dry_run: bool = False
69
70    @property
71    def success(self) -> bool:
72        return len(self.errors) == 0 and len(self.validation_errors) == 0
73
74    @property
75    def status(self) -> str:
76        if self.dry_run:
77            return "dry-run"
78        if self.errors or self.validation_errors:
79            return "completed-with-errors"
80        return "success"

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

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        )

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

60class RegistryEntryResult(BaseModel):
61    """Result of reading a registry entry from GCS.
62
63    This model wraps the raw metadata dictionary with additional context.
64    """
65
66    connector_name: str = Field(description="The connector technical name")
67    version: str = Field(description="The version that was read")
68    bucket_name: str = Field(description="The GCS bucket name")
69    gcs_path: str = Field(description="The GCS path that was read")
70    metadata: dict = Field(description="The raw metadata dictionary")