google-ads-cli 0.0.1__py3-none-any.whl

googleadscli/commands/auth.py

@@ -0,0 +1,150 @@
+"""`gads auth login|status` -- einmalige OAuth2-Einrichtung fuer nicht-interaktive Nutzung."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import client_factory, config, formatting
+from googleadscli.commands._common import run_guarded
+
+app = typer.Typer(no_args_is_help=True, help="OAuth2-Einrichtung und Zugangspruefung")
+
+SCOPES = ["https://www.googleapis.com/auth/adwords"]
+
+
+@app.command("login")
+def login(
+    ctx: typer.Context,
+    client_id: str = typer.Option(..., "--client-id", envvar="GOOGLE_ADS_CLIENT_ID"),
+    client_secret: str = typer.Option(..., "--client-secret", envvar="GOOGLE_ADS_CLIENT_SECRET"),
+    developer_token: str = typer.Option(
+        None,
+        "--developer-token",
+        envvar="GOOGLE_ADS_DEVELOPER_TOKEN",
+        help="Optional: nicht noetig bei Cloud-managed Access ohne klassischen Developer Token",
+    ),
+    login_customer_id: str = typer.Option(
+        None, "--login-customer-id", help="Optionale MCC-CID, die standardmaessig als login-customer-id gesetzt wird"
+    ),
+    no_browser: bool = typer.Option(
+        False, "--no-browser", help="Auth-URL ausgeben statt Browser zu oeffnen (fuer SSH/Remote-Sessions)"
+    ),
+) -> None:
+    """Fuehrt einmalig den interaktiven OAuth2-Consent-Flow aus und speichert den Refresh Token."""
+
+    def _run() -> None:
+        from google_auth_oauthlib.flow import InstalledAppFlow
+
+        client_config = {
+            "installed": {
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "redirect_uris": ["http://localhost"],
+            }
+        }
+        flow = InstalledAppFlow.from_client_config(client_config, scopes=SCOPES)
+        credentials = flow.run_local_server(open_browser=not no_browser)
+
+        data = {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "refresh_token": credentials.refresh_token,
+        }
+        if developer_token:
+            data["developer_token"] = developer_token
+        if login_customer_id:
+            data["login_customer_id"] = login_customer_id.replace("-", "")
+
+        path = config.write_config_file(data)
+        formatting.render({"status": "ok", "config_path": str(path)}, fmt=ctx.obj["format"])
+
+    run_guarded(ctx, _run)
+
+
+@app.command("use-service-account")
+def use_service_account(
+    ctx: typer.Context,
+    json_key_file_path: str = typer.Option(
+        ...,
+        "--json-key-file-path",
+        help="Pfad zur Service-Account-JSON-Schluesseldatei aus der Google Cloud Console",
+    ),
+    developer_token: str = typer.Option(
+        None,
+        "--developer-token",
+        envvar="GOOGLE_ADS_DEVELOPER_TOKEN",
+        help="Optional: nicht noetig bei Cloud-managed Access ohne klassischen Developer Token",
+    ),
+    impersonated_email: str = typer.Option(
+        None,
+        "--impersonated-email",
+        help="Nur fuer Domain-Wide-Delegation: zu impersonierender Workspace-Nutzer. "
+        "Nicht noetig, wenn die client_email der Schluesseldatei direkt als Nutzer auf dem "
+        "Google-Ads-Konto/MCC hinterlegt wurde.",
+    ),
+    login_customer_id: str = typer.Option(None, "--login-customer-id", help="Optionale MCC-CID"),
+) -> None:
+    """Richtet Service-Account-basierte Authentifizierung ein (kein interaktiver Consent noetig).
+
+    Voraussetzung: die client_email aus der JSON-Schluesseldatei muss auf dem
+    Google-Ads-Konto (oder MCC) als Nutzer mit passendem Zugriffslevel hinterlegt sein
+    (Tools & Einstellungen > Zugriff und Sicherheit > Nutzer), es sei denn, es wird
+    stattdessen per --impersonated-email eine Domain-Wide-Delegation genutzt.
+    """
+
+    def _run() -> None:
+        import json as _json
+        from pathlib import Path
+
+        key_path = Path(json_key_file_path).expanduser().resolve()
+        if not key_path.exists():
+            raise config.ConfigError(f"Service-Account-Schluesseldatei nicht gefunden: {key_path}")
+        key_data = _json.loads(key_path.read_text(encoding="utf-8"))
+        if key_data.get("type") != "service_account":
+            raise config.ConfigError(
+                f"Datei {key_path} ist kein Service-Account-Schluessel (type={key_data.get('type')!r})."
+            )
+
+        data: dict = {"json_key_file_path": str(key_path)}
+        if developer_token:
+            data["developer_token"] = developer_token
+        if impersonated_email:
+            data["impersonated_email"] = impersonated_email
+        if login_customer_id:
+            data["login_customer_id"] = login_customer_id.replace("-", "")
+
+        path = config.write_config_file(data)
+        formatting.render(
+            {
+                "status": "ok",
+                "config_path": str(path),
+                "service_account_email": key_data.get("client_email"),
+                "hint": "Stelle sicher, dass diese client_email als Nutzer auf dem Google-Ads-Konto "
+                "hinterlegt ist, falls --impersonated-email nicht gesetzt wurde.",
+            },
+            fmt=ctx.obj["format"],
+        )
+
+    run_guarded(ctx, _run)
+
+
+@app.command("status")
+def status(ctx: typer.Context) -> None:
+    """Prueft die aktuelle Konfiguration gegen die echte API (list_accessible_customers)."""
+
+    def _run() -> None:
+        client = client_factory.build_client(
+            config_path=ctx.obj["config_path"],
+            cli_overrides=ctx.obj["cli_overrides"],
+            version=ctx.obj["version"],
+        )
+        service = client.get_service("CustomerService", version=ctx.obj["version"])
+        response = service.list_accessible_customers()
+        formatting.render(
+            {"status": "ok", "accessible_customers": list(response.resource_names)},
+            fmt=ctx.obj["format"],
+        )
+
+    run_guarded(ctx, _run)

googleadscli/commands/call.py

@@ -0,0 +1,76 @@
+"""`gads call <Service> <Methode>` -- generischer Fallback fuer jede API-Methode.
+
+Deckt alles ab, was kein regulaerer `mutate_*`-Aufruf ist: BatchJobService,
+ConversionUploadService, OfflineUserDataJobService, KeywordPlanService,
+ReachPlanService, GoogleAdsFieldService, CustomerService, Long-Running-
+Operations, etc.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import load_json_arg
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("call")
+    def call_cmd(
+        ctx: typer.Context,
+        service: str = typer.Argument(..., help="Service-Name, z.B. 'BatchJobService'"),
+        method: str = typer.Argument(..., help="Methodenname (snake_case), z.B. 'mutate' oder 'run_batch_job'"),
+        request_json: str = typer.Option(
+            "{}", "--request-json", "-r", help="JSON-Objekt als Request-Payload; mit '@pfad.json' aus Datei laden"
+        ),
+        no_wait: bool = typer.Option(
+            False, "--no-wait", help="Bei Long-Running-Operations nicht auf das Ergebnis warten"
+        ),
+        timeout: float = typer.Option(
+            None, "--timeout", help="Timeout in Sekunden beim Warten auf eine Long-Running-Operation"
+        ),
+    ) -> None:
+        """Ruft eine beliebige Service-Methode generisch auf (voller API-Fallback)."""
+
+        def _run() -> None:
+            payload = load_json_arg(request_json)
+            if payload is not None and not isinstance(payload, dict):
+                raise ValueError("--request-json muss ein JSON-Objekt sein.")
+
+            client = _common.build_client(ctx)
+            result = proto_bridge.invoke_call(
+                client,
+                service,
+                method,
+                payload,
+                wait_for_operation=not no_wait,
+                operation_timeout=timeout,
+                version=ctx.obj["version"],
+            )
+            formatting.render(result, fmt=ctx.obj["format"])
+
+        _common.run_guarded(ctx, _run)
+
+    @app.command("list-services")
+    def list_services_cmd(ctx: typer.Context) -> None:
+        """Listet alle verfuegbaren Service-Namen der aktiven API-Version."""
+
+        def _run() -> None:
+            names = proto_bridge.list_service_names(version=ctx.obj["version"])
+            formatting.render(names, fmt=ctx.obj["format"])
+
+        _common.run_guarded(ctx, _run)
+
+    @app.command("list-methods")
+    def list_methods_cmd(
+        ctx: typer.Context, service: str = typer.Argument(..., help="Service-Name, z.B. 'CampaignService'")
+    ) -> None:
+        """Listet alle aufrufbaren Methoden eines Service auf."""
+
+        def _run() -> None:
+            client = _common.build_client(ctx)
+            methods = proto_bridge.list_service_methods(client, service, version=ctx.obj["version"])
+            formatting.render(methods, fmt=ctx.obj["format"])
+
+        _common.run_guarded(ctx, _run)

googleadscli/commands/fields.py

@@ -0,0 +1,94 @@
+"""`gads fields <resource>` -- Feld-Metadaten der Google Ads API nachschlagen.
+
+Duenner Komfort-Wrapper um GoogleAdsFieldService.SearchGoogleAdsFields (eine
+GAQL-aehnliche Mini-Query-Sprache gegen den globalen Feld-Katalog der API,
+kein Kundenkonto noetig). Beantwortet Fragen wie "welche Felder bietet
+ad_group?" ohne dass man die Mini-Query-Syntax von Hand bauen muss.
+
+Hinweis: Diese Metadaten sagen nur, was *selectable*/*filterable*/*sortable*
+per GAQL ist -- nicht, was per `mutate` *schreibbar* oder mit welchem
+advertising_channel_type kompatibel ist. Das laesst sich nur durch Lesen des
+Resource-Protos (siehe README) oder durch tatsaechliches Ausprobieren
+(--dry-run) herausfinden.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands._common import build_client, run_guarded
+
+app = typer.Typer(no_args_is_help=True, help="Feld-Metadaten der API nachschlagen (kein Kundenkonto noetig)")
+
+_DEFAULT_SELECT = "name, category, data_type, selectable, filterable, sortable, is_repeated, enum_values"
+
+
+@app.command("list")
+def list_fields(
+    ctx: typer.Context,
+    resource: str = typer.Argument(
+        ..., help="Ressourcen- oder Feldname bzw. -praefix, z.B. 'ad_group' oder 'campaign.network_settings'"
+    ),
+    category: str = typer.Option(
+        None,
+        "--category",
+        help="Nur diese Kategorie: RESOURCE|ATTRIBUTE|SEGMENT|METRIC (Default: alle)",
+    ),
+    exact: bool = typer.Option(
+        False, "--exact", help="Nur exakten Feldnamen nachschlagen statt Praefix-Suche"
+    ),
+) -> None:
+    """Listet Feld-Metadaten (selectable/filterable/sortable/enum_values/...) fuer ein Praefix."""
+
+    def _run() -> None:
+        if exact:
+            where = f'name = "{resource}"'
+        else:
+            # Die Mini-Query-Sprache von GoogleAdsFieldService kennt kein OR,
+            # daher listet dies nur die Kindfelder (Praefix); der exakte
+            # Ressourcen-Eintrag selbst laesst sich per 'gads fields show' holen.
+            where = f'name LIKE "{resource}.%"'
+        if category:
+            where += f' AND category = "{category.upper()}"'
+
+        query = f"SELECT {_DEFAULT_SELECT} WHERE {where}"
+
+        client = build_client(ctx)
+        rows = proto_bridge.invoke_call(
+            client,
+            "GoogleAdsFieldService",
+            "search_google_ads_fields",
+            {"query": query},
+            version=ctx.obj["version"],
+        )
+        formatting.render(rows, fmt=ctx.obj["format"])
+
+    run_guarded(ctx, _run)
+
+
+@app.command("show")
+def show_field(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="Exakter Feld- oder Ressourcenname, z.B. 'ad_group.status'"),
+) -> None:
+    """Zeigt die vollstaendigen Metadaten (inkl. selectable_with) fuer genau einen Feld-/Ressourcennamen."""
+
+    def _run() -> None:
+        client = build_client(ctx)
+        rows = proto_bridge.invoke_call(
+            client,
+            "GoogleAdsFieldService",
+            "search_google_ads_fields",
+            {
+                "query": (
+                    "SELECT name, category, data_type, selectable, filterable, sortable, "
+                    "is_repeated, enum_values, selectable_with, attribute_resources, metrics, segments "
+                    f'WHERE name = "{name}"'
+                )
+            },
+            version=ctx.obj["version"],
+        )
+        formatting.render(rows[0] if rows else {}, fmt=ctx.obj["format"])
+
+    run_guarded(ctx, _run)

googleadscli/commands/highlevel/__init__.py

@@ -0,0 +1,18 @@
+"""Komfortbefehle fuer haeufige Workflows -- duenne Wrapper ueber `mutate`/`call`.
+
+Vollstaendigkeit ist bereits durch die generischen Basisbefehle (query/mutate/
+call) gegeben; diese Befehle dienen nur der Ergonomie.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli.commands.highlevel import ad, ad_group, budget, campaign, keyword
+
+app = typer.Typer(no_args_is_help=True, help="Komfortbefehle fuer haeufige Workflows")
+app.add_typer(budget.app, name="budget")
+app.add_typer(campaign.app, name="campaign")
+app.add_typer(ad_group.app, name="ad-group")
+app.add_typer(keyword.app, name="keyword")
+app.add_typer(ad.app, name="ad")

googleadscli/commands/highlevel/ad.py

@@ -0,0 +1,49 @@
+"""`gads hl ad create-responsive-search-ad` -- Responsive Search Ad anlegen."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import normalize_customer_id
+
+app = typer.Typer(no_args_is_help=True, help="Anzeigen anlegen/verwalten")
+
+
+@app.command("create-responsive-search-ad")
+def create_responsive_search_ad(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    ad_group_resource_name: str = typer.Option(..., "--ad-group"),
+    final_url: str = typer.Option(..., "--final-url"),
+    headline: list[str] = typer.Option(..., "--headline", help="Mehrfach angebbar, min. 3 empfohlen"),
+    description: list[str] = typer.Option(..., "--description", help="Mehrfach angebbar, min. 2 empfohlen"),
+    status: str = typer.Option("PAUSED", "--status"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        create_payload = {
+            "ad_group": ad_group_resource_name,
+            "status": status,
+            "ad": {
+                "final_urls": [final_url],
+                "responsive_search_ad": {
+                    "headlines": [{"text": h} for h in headline],
+                    "descriptions": [{"text": d} for d in description],
+                },
+            },
+        }
+        operations = [{"create": create_payload}]
+        result = proto_bridge.run_mutate(
+            client,
+            "ad_group_ad",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)

googleadscli/commands/highlevel/ad_group.py

@@ -0,0 +1,46 @@
+"""`gads hl ad-group create` -- Ad Group anlegen."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import normalize_customer_id
+
+app = typer.Typer(no_args_is_help=True, help="Ad Groups anlegen/verwalten")
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    name: str = typer.Option(..., "--name"),
+    campaign_resource_name: str = typer.Option(..., "--campaign", help="Resource-Name der Kampagne"),
+    status: str = typer.Option("PAUSED", "--status"),
+    ad_group_type: str = typer.Option("SEARCH_STANDARD", "--type", help="AdGroupTypeEnum-Wert"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        operations = [
+            {
+                "create": {
+                    "name": name,
+                    "campaign": campaign_resource_name,
+                    "status": status,
+                    "type": ad_group_type,
+                }
+            }
+        ]
+        result = proto_bridge.run_mutate(
+            client,
+            "ad_group",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)

googleadscli/commands/highlevel/budget.py

@@ -0,0 +1,46 @@
+"""`gads hl budget create` -- CampaignBudget anlegen."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import normalize_customer_id
+
+app = typer.Typer(no_args_is_help=True, help="CampaignBudget anlegen/verwalten")
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    name: str = typer.Option(..., "--name"),
+    amount_micros: int = typer.Option(..., "--amount-micros", help="Tagesbudget in Micros (1 EUR = 1_000_000)"),
+    delivery_method: str = typer.Option("STANDARD", "--delivery-method", help="STANDARD|ACCELERATED"),
+    explicitly_shared: bool = typer.Option(False, "--explicitly-shared"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        operations = [
+            {
+                "create": {
+                    "name": name,
+                    "amount_micros": amount_micros,
+                    "delivery_method": delivery_method,
+                    "explicitly_shared": explicitly_shared,
+                }
+            }
+        ]
+        result = proto_bridge.run_mutate(
+            client,
+            "campaign_budget",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)

googleadscli/commands/highlevel/campaign.py

@@ -0,0 +1,106 @@
+"""`gads hl campaign create|pause|enable|remove` -- Kampagnen verwalten."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import normalize_customer_id
+
+app = typer.Typer(no_args_is_help=True, help="Kampagnen anlegen/verwalten")
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    name: str = typer.Option(..., "--name"),
+    budget_resource_name: str = typer.Option(..., "--budget", help="Resource-Name des CampaignBudget"),
+    advertising_channel_type: str = typer.Option("SEARCH", "--channel-type", help="z.B. SEARCH, DISPLAY, PERFORMANCE_MAX"),
+    status: str = typer.Option("PAUSED", "--status", help="Standard PAUSED, um versehentliche Ausgaben zu vermeiden"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        operations = [
+            {
+                "create": {
+                    "name": name,
+                    "campaign_budget": budget_resource_name,
+                    "advertising_channel_type": advertising_channel_type,
+                    "status": status,
+                }
+            }
+        ]
+        result = proto_bridge.run_mutate(
+            client,
+            "campaign",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)
+
+
+def _set_status(ctx: typer.Context, customer_id: str, resource_name: str, status: str, dry_run: bool) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        operations = [{"update": {"resource_name": resource_name, "status": status}}]
+        result = proto_bridge.run_mutate(
+            client,
+            "campaign",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)
+
+
+@app.command("pause")
+def pause(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    resource_name: str = typer.Argument(..., help="Resource-Name der Kampagne"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    _set_status(ctx, customer_id, resource_name, "PAUSED", dry_run)
+
+
+@app.command("enable")
+def enable(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    resource_name: str = typer.Argument(..., help="Resource-Name der Kampagne"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    _set_status(ctx, customer_id, resource_name, "ENABLED", dry_run)
+
+
+@app.command("remove")
+def remove(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    resource_name: str = typer.Argument(..., help="Resource-Name der Kampagne"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        operations = [{"remove": resource_name}]
+        result = proto_bridge.run_mutate(
+            client,
+            "campaign",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)

googleadscli/commands/highlevel/keyword.py

@@ -0,0 +1,46 @@
+"""`gads hl keyword add` -- Keyword als AdGroupCriterion hinzufuegen."""
+
+from __future__ import annotations
+
+import typer
+
+from googleadscli import formatting, proto_bridge
+from googleadscli.commands import _common
+from googleadscli.utils import normalize_customer_id
+
+app = typer.Typer(no_args_is_help=True, help="Keywords hinzufuegen/verwalten")
+
+
+@app.command("add")
+def add(
+    ctx: typer.Context,
+    customer_id: str = typer.Option(..., "--customer-id", "-c"),
+    ad_group_resource_name: str = typer.Option(..., "--ad-group", help="Resource-Name der Ad Group"),
+    text: str = typer.Option(..., "--text", help="Keyword-Text"),
+    match_type: str = typer.Option("BROAD", "--match-type", help="EXACT|PHRASE|BROAD"),
+    status: str = typer.Option("ENABLED", "--status"),
+    cpc_bid_micros: int = typer.Option(None, "--cpc-bid-micros"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    def _run() -> None:
+        client = _common.build_client(ctx)
+        create_payload: dict = {
+            "ad_group": ad_group_resource_name,
+            "status": status,
+            "keyword": {"text": text, "match_type": match_type},
+        }
+        if cpc_bid_micros is not None:
+            create_payload["cpc_bid_micros"] = cpc_bid_micros
+
+        operations = [{"create": create_payload}]
+        result = proto_bridge.run_mutate(
+            client,
+            "ad_group_criterion",
+            normalize_customer_id(customer_id),
+            operations,
+            validate_only=dry_run,
+            version=ctx.obj["version"],
+        )
+        formatting.render(result, fmt=ctx.obj["format"])
+
+    _common.run_guarded(ctx, _run)