reflex-hosting-cli 0.1.70__tar.gz → 0.1.71a2__tar.gz

{reflex_hosting_cli-0.1.70 → reflex_hosting_cli-0.1.71a2}/CHANGELOG.md

@@ -1,3 +1,34 @@
+## v0.1.71a2 (2026-08-28)
+
+### Bug Fixes
+
+- Fix for older reflex versions
+
+
+## v0.1.71a1 (2026-08-27)
+
+### 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))
+
+### 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_hosting_cli-0.1.70 → reflex_hosting_cli-0.1.71a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: reflex-hosting-cli
-Version: 0.1.70
+Version: 0.1.71a2
 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.71a2/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.71a2/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.70 → reflex_hosting_cli-0.1.71a2}/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.71a2/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.71a2/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.70 → reflex_hosting_cli-0.1.71a2}/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.70 → reflex_hosting_cli-0.1.71a2}/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."""