reflex-hosting-cli 0.1.69__tar.gz → 0.1.71__tar.gz

reflex_hosting_cli-0.1.71/CHANGELOG.md

@@ -0,0 +1,74 @@
+## v0.1.71 (2026-08-28)
+
+### Breaking Changes
+
+- `REFLEX_ACCESS_TOKEN` now takes precedence over the token stored by `reflex login`. Previously the stored token won and the environment variable was consulted only when no token was stored, so exporting it to run a script against a different account had no effect on a machine that had ever logged in — silently, and with no way to tell which credential was in use. Exporting the variable is an explicit choice for that invocation; the config file is ambient state left behind by an earlier login. This changes behavior only when both are present and differ. `reflex cloud whoami` reports which source is in use. ([#6918](https://github.com/reflex-dev/reflex/issues/6918))
+
+### Features
+
+- Added `reflex cloud whoami` and `reflex cloud token`. `whoami` reports the account, org, tier and token source that the CLI is authenticating as, resolving the token against the control plane without ever starting a browser login and without printing the token — it shows a non-reversible fingerprint instead, so two machines can be compared without anyone sharing a secret. `reflex cloud token` takes exactly one of `--print`, `--set TOKEN` or `--clear`: `--print` writes the raw token to stdout for capture (`export REFLEX_ACCESS_TOKEN=$(reflex cloud token --print)`), `--set` validates the token with the control plane before storing it and leaves the previous one in place if it is rejected, and `--clear` removes the stored token, noting when `REFLEX_ACCESS_TOKEN` remains set and will take over. ([#6918](https://github.com/reflex-dev/reflex/issues/6918))
+- On the deploy that first lands an app on GCP, `--hostname` now doubles as the app's Cloud Run service name, so the service in the customer's console reads like the app's URL instead of `app-<uuid>`. A hostname the service-name grammar refuses (leading digit, over 49 characters, or the reserved `app-<uuid>` shape) is skipped with a note and the server generates a name from the app name; later GCP deploys never send one, since the name is pinned to the live service. ([#6937](https://github.com/reflex-dev/reflex/issues/6937))
+- `reflex deploy` uploads a build's two archives straight to storage, concurrently and with a progress bar for each, instead of relaying them through the control plane. ([#6938](https://github.com/reflex-dev/reflex/issues/6938))
+- `reflex cloud deploy` now reports why a deploy failed instead of exiting on a status string: the recorded reason, whether the failure was in your app or on Reflex's side, and the end of the build log when that is what explains it. ([#6948](https://github.com/reflex-dev/reflex/issues/6948))
+
+### Bug Fixes
+
+- The hosting config file (`hosting_v1.json`) is now written atomically. `save_token_to_config` and `delete_token_from_config` opened it with mode `"w"`, truncating it before writing, so a failed write — a full disk, an I/O error, an interrupted process — left an empty file and destroyed the stored access token and selected project. Neither helper reports write failures to the caller (`save_token_to_config` logs a warning, `delete_token_from_config` only a debug message), so this was easy to miss. Both now serialize to a temporary file alongside the target and move it into place, leaving the existing credentials untouched when a write fails. A config that exists but cannot be read is no longer treated as empty either, so `delete_token_from_config` leaves a malformed file alone instead of replacing it; `save_token_to_config` still starts fresh from one, so a corrupt config cannot block re-authenticating. This also covers `reflex login` and `reflex logout`, which share these helpers. ([#6918](https://github.com/reflex-dev/reflex/issues/6918))
+- Fix for older reflex versions
+
+### Miscellaneous
+
+- The hosting CLI's logging goes through standard python `logging`. On reflex 0.9 and up it shares the `reflex-base` console and `LogLevel`; on earlier reflex, where `reflex-base` is not installed, the CLI renders the same output itself. Debug output renders purple (was blue), errors go to stderr (was stdout), and success messages are hidden at `--loglevel warning`. ([#6866](https://github.com/reflex-dev/reflex/issues/6866))
+- `reflex cloud token --set` accepts the token on stdin — pass `-`, or omit the value entirely — so live credentials need not appear in shell history or the process list. When stdin is a terminal it prompts without echoing. `reflex cloud whoami` writes its output directly rather than through the shared console, which applies rich markup and wraps to the terminal width: identifiers now print in full instead of being truncated to fit, and `--json` stays on one line so it can be piped. ([#6918](https://github.com/reflex-dev/reflex/issues/6918))
+- The `reflex deploy` command implementation now lives here, in `reflex_cli.v2.deploy`. The package no longer imports the `reflex` framework at module scope, so it stays importable on its own. ([#6924](https://github.com/reflex-dev/reflex/issues/6924))
+
+
+## v0.1.70 (2026-08-18)
+
+### Deprecations
+
+- `reflex cloud deploy` is renamed to `reflex cloud gcp-standalone`, deprecated as of 0.1.70 and removed in 0.2.0. Inside the `reflex cloud` group, `deploy` meant the standalone gcloud script runner while `reflex deploy` meant the managed platform deploy — one namespace apart, opposite semantics. The old name still works and is hidden from help; invoking it warns, naming both the new name and the managed path. ([#6908](https://github.com/reflex-dev/reflex/issues/6908))
+
+### Features
+
+- `deploy()` accepts `gcp_connection`, `full_deploy` and `strategy`. `gcp_connection` resolves a named GCP connection and pins the app to it (`provider_account_id` on the provider write), instead of every CLI deploy landing on the organization's default connection. `full_deploy` is written before the hostname is reserved, so the reserve hands back the single provider origin the frontend is then compiled against. All three can also be set in the config file. ([#6908](https://github.com/reflex-dev/reflex/issues/6908))
+- `reflex cloud providers list` (also reachable as `providers connections`) now lists each connection's name, default marker and runtime service account, so there is something to pass to `reflex deploy --gcp-connection`. `providers status` lists the same connections. A member who may not read the organization's stored provider accounts still gets the connection names, from the GCP status; their runtime identities are reported as unreadable rather than as the project default. ([#6908](https://github.com/reflex-dev/reflex/issues/6908))
+
+### Bug Fixes
+
+- Optional settings in `cloud.yml` / `pyproject.toml` are validated again on Python 3.10–3.13. A `X | None` annotation reports as `types.UnionType` there, which the config validator did not recognize, so every optional field went unchecked on those versions while being checked on 3.14 — a quoted `full_deploy: "false"` was sent to the server as a truthy string, and a non-string `hostname` or `gcp_connection` failed later with a `TypeError` instead of a config error. ([#6908](https://github.com/reflex-dev/reflex/issues/6908))
+
+
+## v0.1.69 (2026-08-13)
+
+### Features
+
+- `deploy()` accepts `min_instances` and `max_instances`, which are applied to the app before the deployment is submitted so it picks the new autoscaling bounds up. Only the bounds explicitly passed are sent, so apps keep their platform defaults otherwise. ([#6884](https://github.com/reflex-dev/reflex/issues/6884))
+
+### Bug Fixes
+
+- `--vmtype` is no longer dropped when deploying to Google Cloud. The server maps VM types onto Cloud Run CPU/memory limits, so the flag is now passed through; only `--region` is still ignored for that target, since the region comes from the connected GCP account. ([#6884](https://github.com/reflex-dev/reflex/issues/6884))
+
+
+## v0.1.68 (2026-08-03)
+
+### Features
+
+- When a deployment requires approval, `reflex deploy` now reports that the build was submitted for approval and will deploy automatically once approved, instead of polling indefinitely. ([#6797](https://github.com/reflex-dev/reflex/issues/6797))
+- Token validation requests now send an `X-Request-ID` header, and failed validations print the ID (e.g. `Unable to validate access token: ... (auth request id: ...)`) so it can be quoted to support to correlate the failure with server-side logs. ([#6821](https://github.com/reflex-dev/reflex/issues/6821))
+- Added Google Cloud (GCP) as a managed deploy target for `reflex deploy`. When your organization has a GCP account connected (Enterprise tier), `reflex deploy` asks whether to deploy to Reflex Cloud or your GCP account (or pass `--provider gcp` / set `provider: gcp` in your config to skip the prompt), and `reflex cloud providers status` / `list` report the connection state.
+- Added `reflex cloud apps rollback DEPLOYMENT_ID`, which rolls an app back to a previous deployment by redeploying its already-built image without rebuilding from source. `reflex cloud apps history` now reports whether each deployment can be rolled back to.
+- Added optional per-deployment descriptions (changelog notes): set one at deploy time with `reflex deploy --description "..."`, set or clear it later with `reflex cloud apps describe`, and view it in `reflex cloud apps history`.
+
+### Miscellaneous
+
+- Raised the `rich` upper bound to `<16` (adopting rich 15). ([#6678](https://github.com/reflex-dev/reflex/issues/6678))
+
+
+## v0.1.67 (2026-06-17)
+
+### Features
+
+- Added a `--service-account` flag to `reflex deploy --gcp`, letting Cloud Run services run as a least-privilege per-service service account instead of the project's default compute SA. ([#6556](https://github.com/reflex-dev/reflex/issues/6556))
+- Added `--max-instances`, `--allow-unauthenticated/--no-allow-unauthenticated`, `--env KEY=VALUE`, and `--envfile` flags to `reflex deploy --gcp`, letting you cap Cloud Run autoscaling, deploy a private service, and set environment variables at deploy time. ([#6557](https://github.com/reflex-dev/reflex/issues/6557))
+- Added `reflex cloud scan`, which uploads your app source for a Reflex-aware security review and reports security and logic flaws. Supports `--json` output and a `--fail-on` severity gate for CI. ([#6632](https://github.com/reflex-dev/reflex/issues/6632))

{reflex_hosting_cli-0.1.69 → reflex_hosting_cli-0.1.71}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: reflex-hosting-cli
-Version: 0.1.69
+Version: 0.1.71
 Summary: Reflex Hosting CLI
 Author-email: Nikhil Rao <nikhil@reflex.dev>, Alek Petuskey <alek@reflex.dev>
 Maintainer-email: Simon Young <simon@reflex.dev>, Khaleel Al-Adhami <khaleel@reflex.dev>

reflex_hosting_cli-0.1.71/src/reflex_cli/constants/base.py

@@ -0,0 +1,51 @@
+"""Base file for constants that don't fit any other categories."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING
+
+from platformdirs import PlatformDirs
+
+if TYPE_CHECKING:
+    # The two enums are interchangeable, so the shared one is what gets
+    # type-checked; reflex_cli.constants.log_level is checked on its own.
+    from reflex_base.constants.base import LogLevel as LogLevel
+else:
+    # reflex-base only exists from reflex 0.9 on, and the hosting CLI supports
+    # older reflex too, so the fork is the baseline and the shared enum is
+    # adopted when it is there. Older reflex-base releases predate part of the
+    # enum's API, and adopting one of those leaves the CLI calling a method
+    # that does not exist, so those keep the fork as well.
+    from reflex_cli.constants.log_level import LogLevel as LogLevel
+
+    try:
+        from reflex_base.constants.base import LogLevel as _BaseLogLevel
+    except ImportError:
+        pass
+    else:
+        if hasattr(_BaseLogLevel, "to_logging_level"):
+            LogLevel = _BaseLogLevel
+
+
+class Reflex(SimpleNamespace):
+    """Base constants concerning Reflex. This is duplicate of the same class in reflex main."""
+
+    # The name of the Reflex package.
+    MODULE_NAME = "reflex"
+
+    # Files and directories used to init a new project.
+    # The directory to store reflex dependencies.
+    DIR = (
+        # on windows, we use C:/Users/<username>/AppData/Local/reflex.
+        # on macOS, we use ~/Library/Application Support/reflex.
+        # on linux, we use ~/.local/share/reflex.
+        PlatformDirs(MODULE_NAME, False).user_data_dir
+    )
+
+
+class Dirs(SimpleNamespace):
+    """Various directories/paths used by the CLI."""
+
+    # The cloud.yaml file.
+    CLOUD_YAML = "cloud.yml"

reflex_hosting_cli-0.1.71/src/reflex_cli/constants/log_level.py

@@ -0,0 +1,115 @@
+"""The hosting CLI's own LogLevel, used when reflex-base is not installed.
+
+reflex-base only exists from reflex 0.9 on, but the hosting CLI supports older
+reflex too. :mod:`reflex_cli.constants.base` prefers the reflex-base enum when
+it is importable and falls back to this one otherwise; the two are
+interchangeable, with the same members and the same string values.
+"""
+
+from __future__ import annotations
+
+import logging
+from enum import Enum
+
+
+class LogLevel(str, Enum):
+    """The log levels."""
+
+    DEBUG = "debug"
+    DEFAULT = "default"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+    @classmethod
+    def from_string(cls, level: str | None) -> LogLevel | None:
+        """Convert a string to a log level.
+
+        Args:
+            level: The log level as a string.
+
+        Returns:
+            The log level, or None if the string names no level.
+        """
+        if not level:
+            return None
+        try:
+            return cls[level.upper()]
+        except KeyError:
+            return None
+
+    def to_logging_level(self) -> int:
+        """Map this level to a stdlib logging level number.
+
+        DEFAULT acts as a threshold equivalent to INFO.
+
+        Returns:
+            The stdlib logging level.
+        """
+        return _LOGGING_LEVELS[self]
+
+    def subprocess_level(self) -> LogLevel:
+        """Return the log level to hand to a subprocess.
+
+        Returns:
+            This level, or WARNING when it is DEFAULT.
+        """
+        return self if self != LogLevel.DEFAULT else LogLevel.WARNING
+
+    # The str mixin supplies alphabetical comparisons, so all four operators
+    # must be overridden to compare by verbosity rank instead.
+    def __lt__(self, other: LogLevel) -> bool:
+        """Compare log levels.
+
+        Args:
+            other: The other log level.
+
+        Returns:
+            True if the log level is less verbose than the other log level.
+        """
+        return _LOG_LEVEL_RANK[self] < _LOG_LEVEL_RANK[other]
+
+    def __le__(self, other: LogLevel) -> bool:
+        """Compare log levels.
+
+        Args:
+            other: The other log level.
+
+        Returns:
+            True if the log level is less than or equal to the other log level.
+        """
+        return _LOG_LEVEL_RANK[self] <= _LOG_LEVEL_RANK[other]
+
+    def __gt__(self, other: LogLevel) -> bool:
+        """Compare log levels.
+
+        Args:
+            other: The other log level.
+
+        Returns:
+            True if the log level is more verbose-restrictive than the other.
+        """
+        return _LOG_LEVEL_RANK[self] > _LOG_LEVEL_RANK[other]
+
+    def __ge__(self, other: LogLevel) -> bool:
+        """Compare log levels.
+
+        Args:
+            other: The other log level.
+
+        Returns:
+            True if the log level is greater than or equal to the other.
+        """
+        return _LOG_LEVEL_RANK[self] >= _LOG_LEVEL_RANK[other]
+
+
+_LOG_LEVEL_RANK = {level: rank for rank, level in enumerate(LogLevel)}
+_LOGGING_LEVELS = {
+    LogLevel.DEBUG: logging.DEBUG,
+    LogLevel.DEFAULT: logging.INFO,
+    LogLevel.INFO: logging.INFO,
+    LogLevel.WARNING: logging.WARNING,
+    LogLevel.ERROR: logging.ERROR,
+    LogLevel.CRITICAL: logging.CRITICAL,
+}

{reflex_hosting_cli-0.1.69 → reflex_hosting_cli-0.1.71}/src/reflex_cli/core/config.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import dataclasses
+import types
 import typing
 from collections.abc import Sequence
 from dataclasses import dataclass
@@ -101,7 +102,10 @@ def _validate_dispatch(
     if _type in [str, int, float, bool]:
         _validate_type(value, _type, key)
     origin = get_origin(_type)
-    if origin is typing.Union:
+    # `X | None` reports types.UnionType below 3.14, where typing.Union became
+    # the same object; without both, every optional field went unvalidated on
+    # the Python versions this package still supports.
+    if origin is typing.Union or origin is types.UnionType:
         args = typing.get_args(_type)
         if len(args) == 2 and type(None) in args:
             non_optional_type = next(arg for arg in args if arg is not type(None))
@@ -132,6 +136,10 @@ class Config:
     appid: str | None = dataclasses.field(default=None)
     strategy: str | None = dataclasses.field(default=None)
     provider: str | None = dataclasses.field(default=None)
+    gcp_connection: str | None = dataclasses.field(default=None)
+    # None, not False: an unset mode leaves the app's alone, while False would
+    # take every deploy from this config file off full deploy.
+    full_deploy: bool | None = dataclasses.field(default=None)
     include_db: bool = dataclasses.field(default=False)
 
     _cloud_config_path: Path | None = dataclasses.field(default=None)

{reflex_hosting_cli-0.1.69 → reflex_hosting_cli-0.1.71}/src/reflex_cli/utils/__init__.py

@@ -1,11 +1,15 @@
 """Reflex utilities."""
 
+import logging
+
 import click
 
 from reflex_cli.constants.hosting import ReflexHostingCli
 
 from . import console
 
+logger = logging.getLogger(__name__)
+
 
 def disabled_v1_hosting(*args, **kwargs):
     """Print error and exit when using v1 hosting commands.
@@ -18,7 +22,7 @@ def disabled_v1_hosting(*args, **kwargs):
         Exit: Always.
 
     """
-    console.error(
+    logger.error(
         "The alpha hosting service has been decommissioned as of Dec 5, 2024. "
         f"Please upgrade to reflex>={ReflexHostingCli.MINIMUM_REFLEX_VERSION} to use Reflex Cloud hosting."
     )

reflex_hosting_cli-0.1.71/src/reflex_cli/utils/cli_options.py

@@ -0,0 +1,81 @@
+"""Shared click options for the hosting CLI commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from reflex_cli.constants.base import LogLevel
+from reflex_cli.utils import console
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def set_loglevel(ctx: click.Context, self: click.Parameter, value: str | None):
+    """Set the log level.
+
+    Args:
+        ctx: The click context.
+        self: The click command.
+        value: The log level to set.
+    """
+    if value is not None:
+        console.set_log_level(value)
+
+
+loglevel_option = click.option(
+    "--loglevel",
+    "--log-level",
+    "loglevel",
+    type=click.Choice(
+        [loglevel.value for loglevel in LogLevel],
+        case_sensitive=False,
+    ),
+    is_eager=True,
+    callback=set_loglevel,
+    expose_value=False,
+    help="The log level to use.",
+)
+
+
+def set_log_json(ctx: click.Context, self: click.Parameter, value: bool):
+    """Enable machine-readable JSON log output.
+
+    Args:
+        ctx: The click context.
+        self: The click command.
+        value: Whether --json was passed.
+    """
+    if value:
+        try:
+            from reflex_base.utils.log import set_json_mode
+        except ImportError:
+            # JSON records are a reflex-base feature; without it there is no
+            # pipeline to switch, matching reflex_cli.utils.log.is_json_mode.
+            return
+        set_json_mode(True)
+
+
+json_option = click.option(
+    "--json",
+    "log_json",
+    is_flag=True,
+    is_eager=True,
+    callback=set_log_json,
+    expose_value=False,
+    help="Output logs as machine-readable JSON records.",
+)
+
+
+def log_options(func: Callable) -> Callable:
+    """Apply the shared logging CLI options (--loglevel, --json).
+
+    Args:
+        func: The click command callback.
+
+    Returns:
+        The decorated callback.
+    """
+    return loglevel_option(json_option(func))

reflex_hosting_cli-0.1.71/src/reflex_cli/utils/console.py

@@ -0,0 +1,184 @@
+"""Interactive console helpers, shared with reflex-base when it is installed.
+
+Level-gated messages go through :mod:`logging` (see :mod:`reflex_cli.utils.log`);
+what remains here are the rich features that are output rather than logging:
+prompts, tables, spinners and plain prints.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import overload
+
+from reflex_cli.constants.base import LogLevel
+from reflex_cli.utils.log import HAS_REFLEX_BASE, is_json_mode
+from reflex_cli.utils.log import set_log_level as _set_log_level
+
+if HAS_REFLEX_BASE:
+    from reflex_base.utils.console import ask as ask
+    from reflex_base.utils.console import print as print
+    from reflex_base.utils.console import print_table as print_table
+    from reflex_base.utils.console import progress as progress
+    from reflex_base.utils.console import rule as rule
+    from reflex_base.utils.console import status as status
+else:
+    from rich.console import Console, OverflowMethod
+    from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
+    from rich.prompt import Prompt
+    from rich.table import Table
+
+    _console = Console(highlight=False)
+
+    def print(msg: str, **kwargs):
+        """Print a message.
+
+        Args:
+            msg: The message to print.
+            kwargs: Keyword arguments to pass to the print function.
+        """
+        _console.print(msg, **kwargs)
+
+    def print_table(
+        tabular_data: list[list[str]],
+        headers: Sequence[str] = (),
+        overflow: OverflowMethod = "ellipsis",
+    ) -> None:
+        """Print a table to the console.
+
+        Args:
+            tabular_data: The data to print in tabular format.
+            headers: The headers for the table.
+            overflow: What to do with a cell too wide for its column. The
+                default cuts it short; pass "fold" for values a user has to
+                read in full, such as an email or an identifier.
+        """
+        table = Table()
+
+        for column in headers:
+            table.add_column(column, overflow=overflow)
+
+        for row in tabular_data:
+            table.add_row(*row)
+
+        _console.print(table)
+
+    def rule(title: str, **kwargs):
+        """Print a horizontal rule with a title.
+
+        Args:
+            title: The title of the rule.
+            kwargs: Keyword arguments to pass to the print function.
+        """
+        _console.rule(title, **kwargs)
+
+    @overload
+    def ask(
+        question: str,
+        choices: list[str] | None = None,
+        *,
+        show_choices: bool = True,
+    ) -> str: ...
+
+    @overload
+    def ask(
+        question: str,
+        choices: list[str] | None = None,
+        default: str = ...,
+        show_choices: bool = True,
+    ) -> str: ...
+
+    def ask(
+        question: str,
+        choices: list[str] | None = None,
+        default: str | None = None,
+        show_choices: bool = True,
+    ) -> str | None:
+        """Ask the user a question, optionally with a list of choices.
+
+        Args:
+            question: The question to ask the user.
+            choices: A list of choices to select from.
+            default: The default option selected.
+            show_choices: Whether to show the choices.
+
+        Returns:
+            A string with the user input.
+        """
+        return Prompt.ask(
+            question, choices=choices, default=default, show_choices=show_choices
+        )
+
+    def progress():
+        """Create a new progress bar.
+
+        Returns:
+            A new progress bar.
+        """
+        return Progress(
+            *Progress.get_default_columns()[:-1],
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+        )
+
+    def status(*args, **kwargs):
+        """Create a status with a spinner.
+
+        Args:
+            *args: Args to pass to the status.
+            **kwargs: Kwargs to pass to the status.
+
+        Returns:
+            A new status.
+        """
+        return _console.status(*args, **kwargs)
+
+
+def set_log_level(log_level: LogLevel | str | None):
+    """Set the log level, accepting legacy string values and foreign enums.
+
+    Older reflex releases call the CLI's entrypoints directly rather than
+    through click, handing over their own ``reflex.constants.LogLevel``. That is
+    a different class from this package's -- and, before the enum grew
+    ``to_logging_level``, one the CLI cannot use -- so it is resolved by value,
+    the way a legacy plain string is. An unrecognized value falls back to INFO.
+
+    Args:
+        log_level: The log level to set, or None to leave it unchanged.
+    """
+    if log_level is not None and not isinstance(log_level, LogLevel):
+        # A foreign LogLevel carries the level in ``value``; a plain string is
+        # already the value. Either way it resolves by name.
+        log_level = (
+            LogLevel.from_string(getattr(log_level, "value", log_level))
+            or LogLevel.INFO
+        )
+    _set_log_level(log_level)
+
+
+def transfer_progress():
+    """Create a progress bar measured in bytes rather than in steps.
+
+    Lives here rather than beside ``progress`` in reflex-base because only the
+    deploy upload wants it, and the CLI has to render it whether or not
+    reflex-base is installed.
+
+    Returns:
+        A new progress bar, sized and paced for a file transfer.
+    """
+    from rich.progress import (
+        BarColumn,
+        DownloadColumn,
+        Progress,
+        TextColumn,
+        TimeElapsedColumn,
+        TransferSpeedColumn,
+    )
+
+    return Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+        disable=is_json_mode(),
+    )

{reflex_hosting_cli-0.1.69 → reflex_hosting_cli-0.1.71}/src/reflex_cli/utils/dependency.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import importlib.metadata
 import io
+import logging
 import re
 import subprocess
 import sys
@@ -13,6 +14,8 @@ from urllib.parse import urlparse
 from reflex_cli import constants
 from reflex_cli.utils import console
 
+logger = logging.getLogger(__name__)
+
 
 def detect_encoding(filename: Path) -> str | None:
     """Detect the encoding of the given file.
@@ -70,7 +73,7 @@ def check_requirements():
         SystemExit: If no requirements.txt is found.
     """
     if not does_requirements_file_or_pyproject_exist():
-        console.warn("No requirements.txt or pyproject.toml found.")
+        logger.warning("No requirements.txt or pyproject.toml found.")
         return
 
     if not Path(constants.RequirementsTxt.FILE).exists():
@@ -94,8 +97,8 @@ def check_requirements():
             check=True,
         )
     except subprocess.CalledProcessError as cpe:
-        console.debug(f"Unable to run pip freeze in subprocess: {cpe}")
-        console.warn(
+        logger.debug(f"Unable to run pip freeze in subprocess: {cpe}")
+        logger.warning(
             "Unable to detect installed packages in your environment using pip freeze."
             " Please make sure your requirements.txt is up to date."
         )
@@ -112,8 +115,8 @@ def check_requirements():
     if Path(constants.RequirementsTxt.FILE).exists():
         with Path(constants.RequirementsTxt.FILE).open(encoding=encoding) as f:
             current_requirements_lines = set(f)
-            console.debug("Current requirements.txt:")
-            console.debug("".join(current_requirements_lines))
+            logger.debug("Current requirements.txt:")
+            logger.debug("".join(current_requirements_lines))
 
     diff = list(new_requirements_lines - current_requirements_lines)
 
@@ -121,11 +124,11 @@ def check_requirements():
         return
 
     if not current_requirements_lines:
-        console.warn("It seems like there's no requirements.txt in your project.")
+        logger.warning("It seems like there's no requirements.txt in your project.")
         raise SystemExit("No requirements.txt found.")
 
-    console.warn("Detected difference in requirements.txt and python env.")
-    console.warn("The requirements.txt may need to be updated.")
+    logger.warning("Detected difference in requirements.txt and python env.")
+    logger.warning("The requirements.txt may need to be updated.")
     console.ask("Do you wish to proceed? (ctl+c to cancel)")
     return
 

{reflex_hosting_cli-0.1.69 → reflex_hosting_cli-0.1.71}/src/reflex_cli/utils/exceptions.py

@@ -43,6 +43,10 @@ class ResponseError(ReflexHostingCliError):
     """Raised when a response is not as expected."""
 
 
+class ArchiveUploadError(ReflexHostingCliError):
+    """Raised when a build's archives cannot be uploaded to storage."""
+
+
 class ConfigError(ReflexHostingCliError):
     """Raised when there is an error with the config."""