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

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

@@ -1,11 +1,19 @@
-## v0.1.71a2 (2026-08-28)
+## v0.1.72 (2026-09-11)
+
+### Breaking Changes
+
+- Two `reflex cloud` defaults changed. `--interactive` now defaults to whether stdout is a terminal rather than to on, so a pipe, a CI job or an agent is refused with an error instead of waiting at a prompt that nobody answers -- `reflex cloud apps list` in CI with no token now exits 1 with "Token is required for non-interactive mode." Pass `--interactive` to restore the old behavior. And `reflex cloud apps logs --follow` now defaults to off, since following prompts between pages and so never returns on its own; pass `--follow true` for the old behavior. `reflex deploy` takes the same terminal-derived `--interactive`; it keeps `--json` for log records only, since its progress is a stream rather than a result. ([#6917](https://github.com/reflex-dev/reflex/issues/6917))
+
+### Features
+
+- Every `reflex cloud` command now takes `--json`, writing one JSON document to stdout while human-readable messages move to stderr, so the output is parseable without reading a Rich table. Note that a message only lands on stderr if the installed `reflex-base` carries the reservation: against an older one, `--loglevel debug` still writes its records to stdout and they precede the document. ([#6917](https://github.com/reflex-dev/reflex/issues/6917))
 
 ### Bug Fixes
 
-- Fix for older reflex versions
+- Fix version comparison bug that broke compatibility with reflex-0.7.6.post1 ([#6963](https://github.com/reflex-dev/reflex/issues/6963))
 
 
-## v0.1.71a1 (2026-08-27)
+## v0.1.71 (2026-08-28)
 
 ### Breaking Changes
 
@@ -21,6 +29,7 @@
 ### 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
 

{reflex_hosting_cli-0.1.71a2 → reflex_hosting_cli-0.1.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: reflex-hosting-cli
-Version: 0.1.71a2
+Version: 0.1.72
 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 → reflex_hosting_cli-0.1.72}/src/reflex_cli/utils/console.py

@@ -11,7 +11,7 @@ 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 HAS_REFLEX_BASE, is_json_mode, is_stdout_reserved
 from reflex_cli.utils.log import set_log_level as _set_log_level
 
 if HAS_REFLEX_BASE:
@@ -28,6 +28,16 @@ else:
     from rich.table import Table
 
     _console = Console(highlight=False)
+    _console_stderr = Console(stderr=True, highlight=False)
+
+    def _human_console() -> Console:
+        """Resolve the console human-readable output belongs on.
+
+        Returns:
+            The stderr console while stdout is carrying a machine-readable
+            document, and the stdout console otherwise.
+        """
+        return _console_stderr if is_stdout_reserved() else _console
 
     def print(msg: str, **kwargs):
         """Print a message.
@@ -36,7 +46,7 @@ else:
             msg: The message to print.
             kwargs: Keyword arguments to pass to the print function.
         """
-        _console.print(msg, **kwargs)
+        _human_console().print(msg, **kwargs)
 
     def print_table(
         tabular_data: list[list[str]],
@@ -60,7 +70,7 @@ else:
         for row in tabular_data:
             table.add_row(*row)
 
-        _console.print(table)
+        _human_console().print(table)
 
     def rule(title: str, **kwargs):
         """Print a horizontal rule with a title.
@@ -69,7 +79,7 @@ else:
             title: The title of the rule.
             kwargs: Keyword arguments to pass to the print function.
         """
-        _console.rule(title, **kwargs)
+        _human_console().rule(title, **kwargs)
 
     @overload
     def ask(
@@ -105,7 +115,11 @@ else:
             A string with the user input.
         """
         return Prompt.ask(
-            question, choices=choices, default=default, show_choices=show_choices
+            question,
+            choices=choices,
+            default=default,
+            show_choices=show_choices,
+            console=_human_console(),
         )
 
     def progress():
@@ -130,7 +144,7 @@ else:
         Returns:
             A new status.
         """
-        return _console.status(*args, **kwargs)
+        return _human_console().status(*args, **kwargs)
 
 
 def set_log_level(log_level: LogLevel | str | None):

{reflex_hosting_cli-0.1.71a2 → reflex_hosting_cli-0.1.72}/src/reflex_cli/utils/hosting.py

@@ -2640,20 +2640,24 @@ def get_app_logs(
                 timeout=constants.Hosting.TIMEOUT,
             )
             response.raise_for_status()
+    # None rather than an empty list on every path that failed to read: a
+    # caller cannot tell "there are no logs" from "we could not fetch them" out
+    # of `[]`, and the two call for opposite next steps -- one is an answer,
+    # the other is worth retrying.
     except httpx.RequestError:
-        return []
+        return None
     except httpx.HTTPStatusError as ex:
         try:
             ex_details = ex.response.json().get("detail")
         except json.JSONDecodeError:
-            return []
+            return None
         else:
             return f"get app logs failed: {ex_details}"
     else:
         try:
             return response.json()
         except json.JSONDecodeError:
-            return []
+            return None
 
 
 def list_apps(client: AuthenticatedClient, project: str | None = None) -> list[dict]:
@@ -3012,6 +3016,54 @@ def _report_deployment_failure(
     )
 
 
+# The phrases a deployment status is read for. Named here because two callers
+# classify the same string -- the watch loop below, which decides how to report
+# a failure, and `reflex cloud apps status`, which states one as a boolean an
+# agent branches on. A marker spelled twice is two answers waiting to disagree.
+_STATUS_BUILD_ERROR = "build error"
+_STATUS_UNKNOWN_ID = "unable to find status for given id"
+_STATUS_ERROR = "error"
+_STATUS_BAD_RESPONSE = "bad response"
+_STATUS_SUCCEEDED = "completed successfully"
+_STATUS_AWAITING_APPROVAL = "AwaitingApproval"
+# "failed" is not a phrase the watch loop tests for -- "error" already covers
+# the statuses it sees -- and is kept because it is what this predicate
+# replaced. Dropping it could only ever make the answer less strict.
+_STATUS_FAILED = "failed"
+
+
+def deployment_status_failed(status: str) -> bool:
+    """Check whether a deployment status reports a failure.
+
+    Success is asked first, the order `watch_deployment_status` settles it in:
+    a status that has completed is a completed one whatever else it mentions.
+
+    Args:
+        status: The status string the hosting service returned.
+
+    Returns:
+        True if the status says the deployment did not make it.
+    """
+    if any(
+        marker in status
+        for marker in (
+            _STATUS_SUCCEEDED,
+            _STATUS_AWAITING_APPROVAL,
+            _STATUS_BAD_RESPONSE,
+        )
+    ):
+        return False
+    return any(
+        marker in status
+        for marker in (
+            _STATUS_BUILD_ERROR,
+            _STATUS_UNKNOWN_ID,
+            _STATUS_ERROR,
+            _STATUS_FAILED,
+        )
+    )
+
+
 def watch_deployment_status(deployment_id: str, client: AuthenticatedClient) -> bool:
     """Continuously watch the status of a specific deployment.
 
@@ -3035,31 +3087,31 @@ def watch_deployment_status(deployment_id: str, client: AuthenticatedClient) ->
             status = _get_deployment_status(
                 deployment_id=deployment_id, token=client.token
             )
-            if "completed successfully" in status:
+            if _STATUS_SUCCEEDED in status:
                 logger.log(log.SUCCESS, status)
                 break
-            if "AwaitingApproval" in status:
+            if _STATUS_AWAITING_APPROVAL in status:
                 logger.log(
                     log.SUCCESS,
                     "build submitted for approval; it will deploy automatically once an approver approves it.",
                 )
                 break
-            if "build error" in status:
+            if _STATUS_BUILD_ERROR in status:
                 _report_deployment_failure(
                     deployment_id, client.token, status, offer_build_logs=True
                 )
                 return False
-            if "unable to find status for given id" in status:
+            if _STATUS_UNKNOWN_ID in status:
                 # Not a failed deployment but an id that resolves to nothing,
                 # so there is no row to report on and nothing to ask for.
                 logger.error(status)
                 return False
-            if "error" in status:
+            if _STATUS_ERROR in status:
                 _report_deployment_failure(
                     deployment_id, client.token, status, offer_build_logs=False
                 )
                 return False
-            if "bad response" in status:
+            if _STATUS_BAD_RESPONSE in status:
                 logger.warning(status)
                 return True
             if status != current_status:
@@ -3285,13 +3337,16 @@ def read_config(
     return Config.from_yaml_or_toml_or_none()
 
 
-def generate_config(interactive: bool = True, token: str | None = None):
+def generate_config(interactive: bool = True, token: str | None = None) -> Path | None:
     """Generate the config file with app-based prefilling.
 
     Args:
         interactive: Whether to use interactive mode for authentication and app selection.
         token: An existing authentication token to use instead of interactive auth.
 
+    Returns:
+        The path of the config file written, or None if none was.
+
     Raises:
         click.exceptions.Exit: If authentication fails or user cancels operation.
     """
@@ -3299,11 +3354,12 @@ def generate_config(interactive: bool = True, token: str | None = None):
         import yaml
     except ImportError:
         logger.error("Please install PyYAML to use this command: pip install pyyaml")
-        return
+        return None
 
-    if Path("cloud.yml").exists():
+    config_path = Path("cloud.yml")
+    if config_path.exists():
         logger.error("cloud.yml already exists.")
-        return
+        return None
 
     try:
         authenticated_client = get_authenticated_client(
@@ -3344,13 +3400,13 @@ def generate_config(interactive: bool = True, token: str | None = None):
         )
         default = {"name": current_dir_name}
 
-    with Path("cloud.yml").open("w") as config_file:
+    with config_path.open("w") as config_file:
         yaml.dump(default, config_file, default_flow_style=False, sort_keys=False)
     logger.log(log.SUCCESS, "cloud.yml created successfully.")
     logger.info(
         "For more configuration options, see: https://reflex.dev/docs/hosting/config-file/"
     )
-    return
+    return config_path
 
 
 def log_out_on_browser():

{reflex_hosting_cli-0.1.71a2 → reflex_hosting_cli-0.1.72}/src/reflex_cli/utils/log.py

@@ -82,8 +82,12 @@ except ImportError:
             """
             try:
                 style, prefix = _style_for_level(record.levelno)
+                # Errors always go to stderr; everything else joins them there
+                # while stdout is carrying a document.
                 console = (
-                    _console_stderr if record.levelno >= logging.ERROR else _console
+                    _console_stderr
+                    if record.levelno >= logging.ERROR or is_stdout_reserved()
+                    else _console
                 )
                 # Markup is opt-in per record (``extra={"rich": True}``); plain
                 # messages keep their literal brackets.
@@ -129,3 +133,38 @@ except ImportError:
         # no-op when the handler is already attached, so this stays idempotent.
         _CLI_LOGGER.propagate = False
         _CLI_LOGGER.addHandler(_handler)
+
+
+# Asked separately from the names above, and that separation is the whole point.
+# The reservation is younger than the rest of this shim: every published
+# reflex-base exports SUCCESS, is_json_mode and set_log_level, and none of them
+# exports these two. Importing all five together sent an installation with a
+# perfectly good reflex-base down the fallback path entirely -- losing its
+# console, its log parenting and is_json_mode to acquire a feature it was only
+# ever meant to go without.
+try:
+    from reflex_base.utils.log import is_stdout_reserved as is_stdout_reserved
+    from reflex_base.utils.log import reserve_stdout as reserve_stdout
+
+except ImportError:
+    # Tracked here rather than delegated, so `--json` keeps its stdout even
+    # against a reflex-base that has never heard of the reservation. Only this
+    # shim's own sinks consult it; a reflex-base console cannot be told.
+    _stdout_reserved = False
+
+    def reserve_stdout(reserved: bool = True) -> None:
+        """Reserve stdout for a machine-readable document.
+
+        Args:
+            reserved: Whether stdout carries data rather than human output.
+        """
+        global _stdout_reserved
+        _stdout_reserved = reserved
+
+    def is_stdout_reserved() -> bool:
+        """Check whether stdout is reserved for machine-readable output.
+
+        Returns:
+            True while a document owns stdout.
+        """
+        return _stdout_reserved

reflex_hosting_cli-0.1.72/src/reflex_cli/utils/output.py

@@ -0,0 +1,202 @@
+"""Machine-readable output, and the shared options that turn it on.
+
+An agent driving the cloud CLI needs two things a person at a terminal does
+not: output it can parse without regexing a Rich table, and the certainty that
+nothing will stop and wait for a keystroke. ``--json`` answers the first and
+reserves stdout for the document while it does; ``--interactive`` answers the
+second by defaulting to whether stdout is a terminal.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+import click
+
+# Through the CLI's own shim, not reflex_base directly: the hosting CLI has to
+# import against a reflex-base that predates these functions, which is what
+# tests/units/reflex_cli/utils/test_log.py pins.
+from reflex_cli.utils import log
+
+# The spellings that ask for JSON on the command line, and the one that
+# refuses it. Read straight off argv so the group callback can reserve stdout
+# before click has parsed the subcommand's options -- anything it says would
+# otherwise land on stdout ahead of the document.
+_JSON_FLAGS = frozenset({"--json", "-j"})
+_JSON_SHORT = "j"
+_NO_JSON_FLAG = "--no-json"
+
+
+def _json_flag_state(arg: str) -> bool | None:
+    """Read what one command-line argument says about JSON output.
+
+    Args:
+        arg: A single command-line argument.
+
+    Returns:
+        True if it asks for JSON, False if it refuses it, None if it says
+        nothing either way.
+    """
+    if arg == _NO_JSON_FLAG:
+        return False
+    if arg in _JSON_FLAGS:
+        return True
+    # Short flags combine, so `-ij` is `-i -j`. Reading them means this scan
+    # can also fire on a `-j` that click would take as some other option's
+    # value, which is the direction to be wrong in: a message on stderr costs
+    # a little context, one inside the document costs the whole parse.
+    return (
+        True
+        if len(arg) > 1
+        and arg.startswith("-")
+        and not arg.startswith("--")
+        and _JSON_SHORT in arg[1:]
+        else None
+    )
+
+
+def stdout_is_tty() -> bool:
+    """Check whether stdout is attached to a terminal.
+
+    Returns:
+        True if somebody is plausibly watching, False under a pipe, a CI job
+        or an agent.
+    """
+    isatty = getattr(sys.stdout, "isatty", None)
+    if isatty is None:
+        return False
+    try:
+        return bool(isatty())
+    except ValueError:
+        # A closed stream. Nobody is answering a prompt on it either way.
+        return False
+
+
+def _resolve_interactive(
+    ctx: click.Context, param: click.Parameter, value: bool | None
+) -> bool:
+    """Resolve an unset ``--interactive`` against the terminal.
+
+    Args:
+        ctx: The click context.
+        param: The click parameter.
+        value: The flag's value, or None when neither spelling was passed.
+
+    Returns:
+        Whether the command may prompt.
+    """
+    return stdout_is_tty() if value is None else value
+
+
+interactive_option = click.option(
+    "--interactive/--no-interactive",
+    "-i/",
+    "interactive",
+    default=None,
+    callback=_resolve_interactive,
+    help="Whether to prompt for confirmations and choices. Defaults to on when "
+    "stdout is a terminal and off otherwise, so a pipe, a CI job or an agent is "
+    "never left waiting at a prompt.",
+)
+
+
+def json_requested(argv: Sequence[str] | None = None) -> bool:
+    """Check whether a command line asks for JSON output.
+
+    Scanned back to front, so the last flag decides -- the same answer click
+    reaches for a boolean flag pair, which a set membership test cannot give:
+    ``--no-json --json`` enables JSON and ``--json --no-json`` does not.
+
+    Args:
+        argv: The arguments to inspect; defaults to this process's own.
+
+    Returns:
+        True if the command line asks for JSON output.
+    """
+    args = sys.argv[1:] if argv is None else argv
+    for arg in reversed(list(args)):
+        if (state := _json_flag_state(arg)) is not None:
+            return state
+    return False
+
+
+def _hold_reservation(ctx: click.Context, reserved: bool) -> None:
+    """Reserve stdout for this context, releasing it again when it closes.
+
+    The reservation is process-global, so without an explicit release a
+    ``--json`` command leaves every later log line in the process writing to
+    stderr -- which a CLI process never notices, and an embedding one or a
+    second run in the same interpreter does.
+
+    Args:
+        ctx: The click context whose lifetime the reservation follows.
+        reserved: Whether stdout carries data rather than human output.
+    """
+    previous = log.is_stdout_reserved()
+    log.reserve_stdout(reserved)
+    ctx.call_on_close(lambda: log.reserve_stdout(previous))
+
+
+def reserve_stdout_for_argv(
+    argv: Sequence[str] | None = None, *, ctx: click.Context | None = None
+) -> None:
+    """Reserve stdout up front when the command line asks for JSON.
+
+    Always writes the reservation rather than only setting it, so a long-lived
+    process (tests, an embedded runner) cannot inherit the previous
+    invocation's answer.
+
+    Args:
+        argv: The arguments to inspect; defaults to this process's own.
+        ctx: The click context to release the reservation with, if there is one.
+    """
+    reserved = json_requested(argv)
+    if ctx is None:
+        log.reserve_stdout(reserved)
+        return
+    _hold_reservation(ctx, reserved)
+
+
+def _reserve_stdout(ctx: click.Context, param: click.Parameter, value: bool) -> bool:
+    """Reserve stdout for the document once ``--json`` is parsed.
+
+    Args:
+        ctx: The click context.
+        param: The click parameter.
+        value: Whether JSON output was asked for.
+
+    Returns:
+        The flag's value, unchanged.
+    """
+    if value:
+        _hold_reservation(ctx, True)
+    return value
+
+
+json_option = click.option(
+    "--json/--no-json",
+    "-j",
+    "as_json",
+    is_flag=True,
+    is_eager=True,
+    callback=_reserve_stdout,
+    help="Output the result as a single JSON document on stdout. Human-readable "
+    "messages go to stderr instead, so stdout stays parseable.",
+)
+
+
+def print_json(payload: Any) -> None:
+    """Write one JSON document to stdout.
+
+    Deliberately not routed through :mod:`reflex_cli.utils.console`: this is the
+    output the command was asked for, not a message about it, so it goes to
+    stdout even while the console renders to stderr, and is never wrapped in a
+    log record.
+
+    Args:
+        payload: The value to serialize.
+    """
+    click.echo(json.dumps(payload, default=str))