feat(cli): Add image build command to airbyte-cdk CLI

airbyte_cdk/cli/__init__.py

@@ -1 +1,9 @@
-# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""The `airbyte-cdk.cli` module provides command-line interfaces for the Airbyte CDK.
+
+As of now, it includes the following commands:
+
+- `airbyte-cdk`: Commands for working with connectors.
+- `source-declarative-manifest`: Directly invoke the declarative manifests connector.
+
+"""

airbyte_cdk/cli/airbyte_cdk/_image.py

@@ -1,15 +1,138 @@
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
-"""Docker image commands."""
+"""Airbyte CDK 'image' commands.
+
+The `airbyte-cdk` command provides a simplified way to build connector Docker images without requiring the full Airbyte CI pipeline.
+
+```bash
+pip install airbyte-cdk
+
+pipx run airbyte-cdk image [arguments]
+```
+
+
+```bash
+airbyte-cdk image build /path/to/connector
+
+airbyte-cdk image build /path/to/connector --tag custom_tag
+
+airbyte-cdk image build /path/to/connector --no-verify
+
+airbyte-cdk image build /path/to/connector --verbose
+```
+
+
+- `connector_dir`: Path to the connector directory (required)
+- `--tag`: Tag to apply to the built image (default: "dev")
+- `--no-verify`: Skip verification of the built image
+- `--verbose`, `-v`: Enable verbose logging
+
+
+The command reads the connector's metadata from the `metadata.yaml` file, builds a Docker image using the connector's Dockerfile, and verifies the image by running the `spec` command. The image is tagged according to the repository name specified in the metadata and the provided tag.
+
+This command is designed to be a simpler alternative to the `airbyte-ci build` command, using Docker directly on the host machine instead of Dagger.
+"""
+
+import sys
+from pathlib import Path
 
 import click
 
+from airbyte_cdk.models.connector_metadata import MetadataFile
+from airbyte_cdk.utils.docker import (
+    build_from_base_image,
+    build_from_dockerfile,
+    verify_docker_installation,
+    verify_image,
+)
+
 
 @click.group(name="image")
 def image_cli_group() -> None:
-    """Docker image commands."""
-    pass
+    """Commands for working with connector Docker images."""
+
+
+@image_cli_group.command()
+@click.argument(
+    "connector_directory",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+)
+@click.option("--tag", default="dev", help="Tag to apply to the built image (default: dev)")
+@click.option("--no-verify", is_flag=True, help="Skip verification of the built image")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+def build(
+    connector_directory: Path,
+    tag: str = "dev",
+    no_verify: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Build a connector Docker image.
+
+    This command builds a Docker image for a connector, using either
+    the connector's Dockerfile or a base image specified in the metadata.
+    The image is built for both AMD64 and ARM64 architectures.
+    """
+    if not verify_docker_installation():
+        click.echo(
+            "Docker is not installed or not running. Please install Docker and try again.", err=True
+        )
+        sys.exit(1)
+
+    try:
+        metadata = MetadataFile.from_file(connector_directory / "metadata.yaml")
+        click.echo(f"Connector: {metadata.data.dockerRepository}")
+        click.echo(f"Version: {metadata.data.dockerImageTag}")
+
+        if metadata.data.language:
+            click.echo(f"Connector language from metadata: {metadata.data.language}")
+        else:
+            click.echo("Connector language not specified in metadata")
+
+        try:
+            import subprocess
+
+            result = subprocess.run(
+                ["docker", "buildx", "inspect"], capture_output=True, text=True, check=False
+            )
+
+            if "linux/amd64" in result.stdout and "linux/arm64" in result.stdout:
+                platforms = "linux/amd64,linux/arm64"
+                click.echo(f"Building for platforms: {platforms}")
+            else:
+                platforms = "linux/amd64"
+                click.echo(
+                    f"Multi-platform build not available. Building for platform: {platforms}"
+                )
+                click.echo(
+                    "To enable multi-platform builds, configure Docker buildx with: docker buildx create --use"
+                )
+        except Exception:
+            platforms = "linux/amd64"
+            click.echo(f"Multi-platform build check failed. Building for platform: {platforms}")
+
+        if metadata.data.connectorBuildOptions and metadata.data.connectorBuildOptions.baseImage:
+            image_name = build_from_base_image(connector_directory, metadata, tag, platforms)
+        else:
+            image_name = build_from_dockerfile(connector_directory, metadata, tag, platforms)
+
+        if not no_verify:
+            if verify_image(image_name):
+                click.echo(f"Build completed successfully: {image_name}")
+                sys.exit(0)
+            else:
+                click.echo(f"Built image failed verification: {image_name}", err=True)
+                sys.exit(1)
+        else:
+            click.echo(f"Build completed successfully (without verification): {image_name}")
+            sys.exit(0)
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+        if verbose:
+            import traceback
+
+            click.echo(traceback.format_exc(), err=True)
+        sys.exit(1)
 
 
-__all__ = [
+__all___ = [
     "image_cli_group",
 ]

airbyte_cdk/models/connector_metadata.py

@@ -0,0 +1,78 @@
+"""Models to represent the structure of a `metadata.yaml` file."""
+
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ConnectorLanguage(str, Enum):
+    """Connector implementation language."""
+
+    PYTHON = "python"
+    JAVA = "java"
+    LOW_CODE = "low-code"
+    MANIFEST_ONLY = "manifest-only"
+    UNKNOWN = "unknown"
+
+
+class ConnectorBuildOptions(BaseModel):
+    """Connector build options from metadata.yaml."""
+
+    model_config = {"extra": "allow"}
+
+    baseImage: str | None = Field(
+        None,
+        description="Base image to use for building the connector",
+    )
+    path: str | None = Field(
+        None,
+        description="Path to the connector code within the repository",
+    )
+
+
+class ConnectorMetadata(BaseModel):
+    """Connector metadata from metadata.yaml."""
+
+    model_config = {"extra": "allow"}
+
+    dockerRepository: str = Field(..., description="Docker repository for the connector image")
+    dockerImageTag: str = Field(..., description="Docker image tag for the connector")
+    language: ConnectorLanguage | None = Field(
+        None, description="Language of the connector implementation"
+    )
+    connectorBuildOptions: ConnectorBuildOptions | None = Field(
+        None, description="Options for building the connector"
+    )
+
+
+class MetadataFile(BaseModel):
+    """Represents the structure of a metadata.yaml file."""
+
+    model_config = {"extra": "allow"}
+
+    data: ConnectorMetadata = Field(..., description="Connector metadata")
+
+    @classmethod
+    def from_file(
+        cls,
+        file_path: Path,
+    ) -> MetadataFile:
+        """Load metadata from a YAML file."""
+        if not file_path.exists():
+            raise FileNotFoundError(f"Metadata file not found: {file_path!s}")
+
+        metadata_content = file_path.read_text()
+        metadata_dict = yaml.safe_load(metadata_content)
+
+        if not metadata_dict or "data" not in metadata_dict:
+            raise ValueError(
+                "Invalid metadata format: missing 'data' field in YAML file '{file_path!s}'"
+            )
+
+        metadata_file = MetadataFile.model_validate(metadata_dict)
+        return metadata_file