tinybird 0.0.1.dev306__py3-none-any.whl → 1.0.5__py3-none-any.whl

tinybird/tb/modules/local_common.py

@@ -4,6 +4,7 @@ import logging
 import os
 import re
 import subprocess
+import threading
 import time
 import uuid
 from typing import Any, Dict, Optional
@@ -19,6 +20,15 @@ from tinybird.tb.client import AuthNoTokenException, TinyB
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import CLILocalException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
+from tinybird.tb.modules.local_logs import (
+    check_memory_sufficient,
+    clickhouse_is_ready,
+    container_stats,
+    events_is_ready,
+    local_authentication_is_ready,
+    redis_is_ready,
+    server_is_ready,
+)
 from tinybird.tb.modules.secret_common import load_secrets
 from tinybird.tb.modules.telemetry import add_telemetry_event
 
@@ -35,11 +45,18 @@ def get_tinybird_local_client(
     config_obj: Dict[str, Any], test: bool = False, staging: bool = False, silent: bool = False
 ) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
-
-    config = get_tinybird_local_config(config_obj, test=test, silent=silent)
-    client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
-    load_secrets(config_obj.get("path", ""), client)
-    return client
+    try:
+        config = get_tinybird_local_config(config_obj, test=test, silent=silent)
+        client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
+        load_secrets(config_obj.get("path", ""), client)
+        return client
+    # if some of the API calls to tinybird local fail due to a JSONDecodeError, it means that container is running but it's unhealthy
+    except json.JSONDecodeError:
+        raise CLILocalException(
+            message=FeedbackManager.error(
+                message="Tinybird Local is running but it's unhealthy. Please check if it's running and try again. If the problem persists, please run `tb local restart` and try again."
+            )
+        )
 
 
 def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, silent: bool = False) -> CLIConfig:
@@ -140,6 +157,7 @@ def get_local_tokens() -> Dict[str, str]:
                 },
             )
 
+            # TODO: If docker errors persist, explain that you can use custom environments too once they are open for everyone
             if container and container.status == "running":
                 if container.health == "healthy":
                     raise CLILocalException(
@@ -219,7 +237,7 @@ def get_local_tokens() -> Dict[str, str]:
                 default=True,
             )
             if yes:
-                click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
+                click.echo(FeedbackManager.highlight(message="» Watching Tinybird Local... (Press Ctrl+C to stop)"))
                 docker_client = get_docker_client()
                 start_tinybird_local(docker_client, False)
                 click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
@@ -237,6 +255,7 @@ def start_tinybird_local(
     skip_new_version: bool = True,
     user_token: Optional[str] = None,
     workspace_token: Optional[str] = None,
+    watch: bool = False,
 ) -> None:
     """Start the Tinybird container."""
     pull_show_prompt = False
@@ -299,18 +318,151 @@ def start_tinybird_local(
         )
 
     click.echo(FeedbackManager.info(message="* Waiting for Tinybird Local to be ready..."))
+
+    if watch:
+        # Stream logs in a separate thread while monitoring container health
+        container_ready = threading.Event()
+        stop_requested = threading.Event()
+        health_check: dict[str, str] = {}
+
+        log_thread = threading.Thread(
+            target=stream_logs_with_health_check,
+            args=(container, container_ready, stop_requested),
+            daemon=True,
+        )
+        log_thread.start()
+
+        health_check_thread = threading.Thread(
+            target=check_endpoints_health,
+            args=(container, docker_client, container_ready, stop_requested, health_check),
+            daemon=True,
+        )
+        health_check_thread.start()
+
+        # Monitor container health in main thread
+        memory_warning_shown = False
+        try:
+            while True:
+                container.reload()  # Refresh container attributes
+                health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+                if not container_ready.is_set():
+                    click.echo(FeedbackManager.info(message=f"* Tinybird Local container status: {health}"))
+                    stats = container_stats(container, docker_client)
+                    click.echo(f"* {stats}")
+
+                    # Check memory sufficiency
+                    if not memory_warning_shown:
+                        is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                        if not is_sufficient and warning_msg:
+                            click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                            memory_warning_shown = True
+
+                if health == "healthy":
+                    click.echo(FeedbackManager.highlight(message="» Checking services..."))
+                    stats = container_stats(container, docker_client)
+                    click.echo(FeedbackManager.info(message=f"✓ Tinybird Local container ({stats})"))
+
+                    # Check memory sufficiency before checking services
+                    if not memory_warning_shown:
+                        is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                        if not is_sufficient and warning_msg:
+                            click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                            memory_warning_shown = True
+
+                    if not clickhouse_is_ready(container):
+                        raise Exception("Clickhouse is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Clickhouse"))
+
+                    if not redis_is_ready(container):
+                        raise Exception("Redis is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Redis"))
+
+                    if not server_is_ready(container):
+                        raise Exception("Server is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Server"))
+
+                    if not events_is_ready(container):
+                        raise Exception("Events is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Events"))
+
+                    if not local_authentication_is_ready(container):
+                        raise Exception("Tinybird Local authentication is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Tinybird Local authentication"))
+                    container_ready.set()
+                    # Keep monitoring and streaming logs until Ctrl+C or health check failure
+                    while True:
+                        # Check if health check detected an error
+                        if stop_requested.is_set() and health_check.get("error"):
+                            time.sleep(0.5)  # Give log thread time to finish printing
+                            raise CLILocalException(
+                                FeedbackManager.error(
+                                    message=f"{health_check.get('error')}\n"
+                                    "Please run `tb local restart` to restart the container."
+                                )
+                            )
+                            return
+                        time.sleep(1)
+                if health == "unhealthy":
+                    stop_requested.set()
+                    # Check if memory might be the cause of unhealthy status
+                    is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                    error_msg = "Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+                    if not is_sufficient and warning_msg:
+                        error_msg = (
+                            "Tinybird Local is unhealthy.\nnAfter adjusting memory, try running `tb local restart`."
+                        )
+                    raise CLILocalException(FeedbackManager.error(message=error_msg))
+                time.sleep(5)
+        except KeyboardInterrupt:
+            stop_requested.set()
+            click.echo(FeedbackManager.highlight(message="» Stopping Tinybird Local..."))
+            try:
+                container.stop()
+                click.echo(FeedbackManager.success(message="✓ Tinybird Local stopped."))
+            except KeyboardInterrupt:
+                click.echo(FeedbackManager.warning(message="⚠ Forced exit. Container may still be running."))
+                click.echo(FeedbackManager.info(message="  Run `tb local stop` to stop the container manually."))
+            return
+
+    # Non-watch mode: just wait for container to be healthy
+    memory_warning_shown = False
     while True:
         container.reload()  # Refresh container attributes
         health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+        click.echo(FeedbackManager.info(message=f"* Tinybird Local container status: {health}"))
+        stats = container_stats(container, docker_client)
+        click.echo(f"* {stats}")
+
+        # Check memory sufficiency
+        if not memory_warning_shown:
+            is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+            if not is_sufficient and warning_msg:
+                click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                memory_warning_shown = True
+
         if health == "healthy":
+            click.echo(FeedbackManager.highlight(message="» Checking services..."))
+            stats = container_stats(container, docker_client)
+            click.echo(FeedbackManager.info(message=f"✓ Tinybird Local container ({stats})"))
+            if not clickhouse_is_ready(container):
+                raise Exception("Clickhouse is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Clickhouse"))
+            if not redis_is_ready(container):
+                raise Exception("Redis is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Redis"))
+            if not server_is_ready(container):
+                raise Exception("Server is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Server"))
+            if not events_is_ready(container):
+                raise Exception("Events is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Events"))
+            if not local_authentication_is_ready(container):
+                raise Exception("Tinybird Local authentication is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Tinybird Local authentication"))
             break
         if health == "unhealthy":
-            raise CLILocalException(
-                FeedbackManager.error(
-                    message="Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
-                )
-            )
-
+            error_msg = "Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+            raise CLILocalException(FeedbackManager.error(message=error_msg))
         time.sleep(5)
 
     # Remove tinybird-local dangling images to avoid running out of disk space
@@ -429,7 +581,8 @@ def get_docker_client() -> DockerClient:
                 message=(
                     f"No container runtime is running. Make sure a Docker-compatible runtime is installed and running. "
                     f"{docker_location_message}\n\n"
-                    "If you're using a custom location, please provide it using the DOCKER_HOST environment variable."
+                    "If you're using a custom location, please provide it using the DOCKER_HOST environment variable.\n\n"
+                    "Alternatively, you can use Tinybird branches to develop your project without Docker. Run `tb branch create my_feature_branch` to create one. Learn more at: https://www.tinybird.co/docs/forward/test-and-deploy/branches"
                 )
             )
         )
@@ -474,3 +627,157 @@ def get_use_aws_creds() -> dict[str, str]:
         )
 
     return credentials
+
+
+SERVICE_COLORS = {
+    "[EVENTS]": "\033[95m",  # Magenta
+    "[SERVER]": "\033[94m",  # Blue
+    "[HEALTH]": "\033[96m",  # Cyan
+    "[KAFKA]": "\033[93m",  # Yellow
+    "[AUTH]": "\033[90m",  # Gray
+}
+
+RESET = "\033[0m"
+
+
+def check_endpoints_health(
+    container: Container,
+    docker_client: DockerClient,
+    container_ready: threading.Event,
+    stop_requested: threading.Event,
+    health_check: dict[str, str],
+) -> None:
+    """Continuously check /tokens and /v0/health endpoints"""
+    # Wait for container to be ready before starting health checks
+    container_ready.wait()
+
+    # Give container a moment to fully start up
+    time.sleep(2)
+
+    check_interval = 10  # Check every 10 seconds
+
+    while not stop_requested.is_set():
+        try:
+            # Check /tokens endpoint
+            tokens_response = requests.get(f"{TB_LOCAL_ADDRESS}/tokens", timeout=5)
+            if tokens_response.status_code != 200:
+                health_check["error"] = (
+                    f"/tokens endpoint returned status {tokens_response.status_code}. Tinybird Local may be unhealthy."
+                )
+                stop_requested.set()
+                break
+
+            # Check /v0/health endpoint
+            health_response = requests.get(f"{TB_LOCAL_ADDRESS}/v0/health", timeout=5)
+            if health_response.status_code != 200:
+                health_check["error"] = (
+                    f"/v0/health endpoint returned status {health_response.status_code}. "
+                    "Tinybird Local may be unhealthy."
+                )
+                stop_requested.set()
+                break
+
+            # Verify tokens response has expected structure
+            try:
+                tokens_data = tokens_response.json()
+                if not all(key in tokens_data for key in ["user_token", "admin_token", "workspace_admin_token"]):
+                    health_check["error"] = (
+                        "/tokens endpoint returned unexpected data. Tinybird Local may be unhealthy."
+                    )
+                    stop_requested.set()
+                    break
+            except json.JSONDecodeError:
+                health_check["error"] = "/tokens endpoint returned invalid JSON. Tinybird Local may be unhealthy."
+                stop_requested.set()
+                break
+
+        except Exception as e:
+            # Check if it's a connection error
+            error_str = str(e)
+            if "connect" in error_str.lower() or "timeout" in error_str.lower():
+                health_check["error"] = f"Failed to connect to Tinybird Local: {error_str}"
+            else:
+                health_check["error"] = f"Health check failed: {error_str}"
+            stop_requested.set()
+            break
+
+        if container_ready.is_set():
+            stats = container_stats(container, docker_client)
+            click.echo(f"{SERVICE_COLORS['[HEALTH]']}[HEALTH]{RESET} {stats}")
+
+        # Wait before next check
+        for _ in range(check_interval):
+            if stop_requested.is_set():
+                break
+            time.sleep(1)
+
+
+def stream_logs_with_health_check(
+    container: Container, container_ready: threading.Event, stop_requested: threading.Event
+) -> None:
+    """Stream logs and monitor container health in parallel"""
+    # Wait for container to be ready before starting health checks
+    container_ready.wait()
+
+    # Give container a moment to fully start up
+    time.sleep(2)
+
+    retry_count = 0
+    max_retries = 10
+    exec_result = None
+
+    while retry_count < max_retries and not stop_requested.is_set():
+        try:
+            # Try to tail the log files (only new logs, not historical)
+            # Use -F to follow by name and retry if files don't exist yet
+            log_files = {
+                "/var/log/tinybird-local-server.log": "SERVER",
+                "/var/log/tinybird-local-hfi.log": "EVENTS",
+                "/var/log/tinybird-local-setup.log": "AUTH",
+                "/var/log/tinybird-local-kafka.log": "KAFKA",
+            }
+            # Build commands to tail each file and prefix with its label (using stdbuf for unbuffered output)
+            tail_commands = [
+                f'tail -n 0 -f {path} | stdbuf -oL sed "s/^/[{source}] /"' for path, source in log_files.items()
+            ]
+            # Join with & to run in parallel, then wait for all
+            cmd = f"sh -c '({' & '.join(tail_commands)}) & wait'"
+            exec_result = container.exec_run(cmd, stream=True, tty=False, stdout=True, stderr=True)
+            break  # Success, exit retry loop
+        except Exception:
+            # Log file might not exist yet, wait and retry
+            retry_count += 1
+            if retry_count < max_retries:
+                time.sleep(2)
+
+    # Stream logs continuously
+    if exec_result:
+        try:
+            for line in exec_result.output:
+                if stop_requested.is_set():
+                    break
+
+                raw_line = line.decode("utf-8").rstrip()
+                lines = raw_line.split("\n")
+
+                # Print "ready" message when container becomes healthy
+                if container_ready.is_set() and not hasattr(stream_logs_with_health_check, "ready_printed"):
+                    click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+                    stream_logs_with_health_check.ready_printed = True  # type: ignore
+
+                for line in lines:
+                    # Apply color to service label
+                    for service, color in SERVICE_COLORS.items():
+                        if line.startswith(service):
+                            message = line[len(service) :]
+                            # extract content of message="...""
+                            match = re.search(r'message="([^"]*)"', message)
+                            if match:
+                                message = match.group(1)
+                            line = f"{color}{service}{RESET} {message}"
+                            break
+
+                    click.echo(line)
+
+        except Exception:
+            pass  # Silently ignore errors when stream is interrupted

tinybird/tb/modules/local_logs.py

@@ -0,0 +1,209 @@
+import json
+import platform
+from typing import Optional
+
+from docker.client import DockerClient
+from docker.models.containers import Container
+
+
+def clickhouse_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("clickhouse 'SELECT 1 AS healthcheck'")
+        return result.output.decode("utf-8").strip() == "1"
+    except Exception:
+        return False
+
+
+def redis_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("redis-cli PING")
+        return result.output.decode("utf-8").strip() == "PONG"
+    except Exception:
+        return False
+
+
+def local_authentication_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8000/tokens")
+        data = json.loads(result.output.decode("utf-8").strip())
+        token_keys = ["admin_token", "user_token", "workspace_admin_token"]
+        return all(key in data for key in token_keys)
+    except Exception:
+        return False
+
+
+def server_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8001/health/liveness")
+        is_live = result.output.decode("utf-8").strip() == "alive"
+        if not is_live:
+            return False
+        result = container.exec_run("curl -s http://localhost:8001/health/readiness")
+        return result.output.decode("utf-8").strip() == "ready"
+    except Exception:
+        return False
+
+
+def events_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8042/health/liveness")
+        is_live = result.output.decode("utf-8").strip() == "alive"
+        if not is_live:
+            return False
+        result = container.exec_run("curl -s http://localhost:8042/health/readiness")
+        return result.output.decode("utf-8").strip() == "ready"
+    except Exception:
+        return False
+
+
+def container_is_ready(container: Container) -> bool:
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    status = container.status
+    return health == "healthy" and status == "running"
+
+
+def container_is_starting(container: Container) -> bool:
+    status = container.status
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    return status == "restarting" or (status == "running" and health == "starting")
+
+
+def container_is_stopping(container: Container) -> bool:
+    status = container.status
+    return status == "stopping"
+
+
+def container_is_unhealthy(container: Container) -> bool:
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    return health == "unhealthy"
+
+
+def bytes_to_gb(b):
+    return round(b / (1024**3), 2)  # two decimal places (e.g., 1.75 GB)
+
+
+def get_container(client, name_or_id):
+    return client.containers.get(name_or_id)
+
+
+def get_image_arch(client, image_ref):
+    try:
+        image = client.images.get(image_ref)
+        return (image.attrs.get("Architecture") or "").lower()
+    except Exception:
+        return ""
+
+
+def is_emulated(host_arch, image_arch):
+    # Architecture equivalents - same arch with different names
+    arch_equivalents = [
+        {"x86_64", "amd64"},
+        {"aarch64", "arm64"},
+    ]
+
+    if not host_arch or not image_arch:
+        return False
+
+    if host_arch == image_arch:
+        return False
+
+    # Check if architectures are equivalent
+    return all(not (host_arch in equiv_set and image_arch in equiv_set) for equiv_set in arch_equivalents)
+
+
+def mem_usage_percent(container):
+    st = container.stats(stream=False)
+    mem = st.get("memory_stats", {}) or {}
+    limit = float(mem.get("limit") or 0.0)
+    usage = float(mem.get("usage") or 0.0)
+    stats = mem.get("stats", {}) or {}
+    inactive = float(stats.get("total_inactive_file") or stats.get("inactive_file") or 0.0)
+    used = max(usage - inactive, 0.0)
+    pct = (used / limit * 100.0) if limit > 0 else None
+    return used, limit, pct
+
+
+def container_stats(container: Container, client: DockerClient):
+    host_arch = platform.machine().lower()
+    image_arch = get_image_arch(client, container.attrs.get("Config", {}).get("Image", ""))
+    emu = is_emulated(host_arch, image_arch)
+    used_b, limit_b, pct = mem_usage_percent(container)
+    pct = round(pct, 1) if pct is not None else None
+    used_gb = bytes_to_gb(used_b)
+    limit_gb = bytes_to_gb(limit_b) if limit_b > 0 else None
+    lim_str = f"{limit_gb} GB" if limit_gb else "no-limit"
+    arch_str = f"arch={host_arch} img={image_arch or 'unknown'} emulated={str(emu).lower()}"
+    cpu_usage_pct = cpu_usage_stats(container)
+    return f"memory {used_gb}/{lim_str} cpu {cpu_usage_pct} {arch_str}"
+
+
+def cpu_usage_stats(container: Container) -> str:
+    st = container.stats(stream=False)
+    cpu = st.get("cpu_stats", {}) or {}
+    cpu_usage = cpu.get("cpu_usage", {}) or {}
+    total_usage = cpu_usage.get("total_usage", 0)
+    system_cpu_usage = cpu.get("system_cpu_usage", 0)
+    pct = (total_usage / system_cpu_usage * 100.0) if system_cpu_usage > 0 else None
+    return f"{round(pct, 1) if pct is not None else 'N/A'}%"
+
+
+def check_memory_sufficient(container: Container, client: DockerClient) -> tuple[bool, Optional[str]]:
+    """
+    Check if container has sufficient memory.
+
+    Returns:
+        tuple[bool, str | None]: (is_sufficient, warning_message)
+            - is_sufficient: True if memory is sufficient, False otherwise
+            - warning_message: None if sufficient, otherwise a warning message
+    """
+    host_arch = platform.machine().lower()
+    image_arch = get_image_arch(client, container.attrs.get("Config", {}).get("Image", ""))
+    is_emu = is_emulated(host_arch, image_arch)
+    used_b, limit_b, pct = mem_usage_percent(container)
+
+    if limit_b <= 0:
+        # No memory limit set
+        return True, None
+
+    limit_gb = bytes_to_gb(limit_b)
+    used_gb = bytes_to_gb(used_b)
+
+    # Memory thresholds
+    # For emulated containers, we need more memory and lower threshold
+    HIGH_MEMORY_THRESHOLD_EMULATED = 70.0  # 70% for emulated
+    HIGH_MEMORY_THRESHOLD_NATIVE = 85.0  # 85% for native
+    MINIMUM_MEMORY_GB_EMULATED = 6.0  # Minimum 6GB for emulated
+    MINIMUM_MEMORY_GB_NATIVE = 4.0  # Minimum 4GB for native
+
+    warnings = []
+
+    # Check memory percentage
+    if pct is not None:
+        threshold = HIGH_MEMORY_THRESHOLD_EMULATED if is_emu else HIGH_MEMORY_THRESHOLD_NATIVE
+        if pct >= threshold:
+            warnings.append(
+                f"Memory usage is at {pct:.1f}% ({used_gb}/{limit_gb:.2f} GB), "
+                f"which exceeds the recommended threshold of {threshold:.0f}%."
+            )
+
+    # Check absolute memory limit
+    min_memory = MINIMUM_MEMORY_GB_EMULATED if is_emu else MINIMUM_MEMORY_GB_NATIVE
+    if limit_gb < min_memory:
+        arch_msg = f" (running emulated {image_arch} on {host_arch})" if is_emu else ""
+        warnings.append(
+            f"Memory limit is {limit_gb:.2f} GB{arch_msg}, but at least {min_memory:.1f} GB is recommended."
+        )
+
+    if warnings:
+        warning_msg = " ".join(warnings)
+        if is_emu:
+            warning_msg += (
+                "\n"
+                f"You're running an emulated container ({image_arch} on {host_arch}), which requires more resources.\n"
+                "Consider increasing Docker's memory allocation."
+            )
+        else:
+            warning_msg += "Consider increasing Docker's memory allocation."
+        return False, warning_msg
+
+    return True, None

tinybird/tb/modules/login.py

@@ -15,12 +15,13 @@ from tinybird.tb.modules.telemetry import add_telemetry_event
     "--host",
     type=str,
     default=None,
-    help="Set custom host if it's different than https://api.europe-west2.gcp.tinybird.co. See https://www.tinybird.co/docs/api-reference/overview#regions-and-endpoints for the available list of regions.",
+    help="Set the API host to authenticate to. See https://www.tinybird.co/docs/api-reference#regions-and-endpoints for the available list of regions.",
 )
 @click.option(
     "--auth-host",
     default="https://cloud.tinybird.co",
-    help="Set the host to authenticate to. If unset, the default host will be used.",
+    help="Set the auth host to authenticate to. If unset, the default host will be used.",
+    hidden=True,
 )
 @click.option(
     "--workspace",