modal 1.4.3.dev2__tar.gz → 1.4.3.dev4__tar.gz

{modal-1.4.3.dev2 → modal-1.4.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.3.dev2
+Version: 1.4.3.dev4
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -25,7 +25,6 @@ Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
 Requires-Dist: synchronicity~=0.12.1
 Requires-Dist: toml
-Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
 Requires-Dist: types-toml
 Requires-Dist: watchfiles

{modal-1.4.3.dev2 → modal-1.4.3.dev4}/modal/_utils/blob_utils.py

@@ -6,7 +6,7 @@ import os
 import platform
 import time
 from collections.abc import AsyncIterator
-from contextlib import AbstractContextManager, contextmanager
+from contextlib import AbstractContextManager, asynccontextmanager, contextmanager
 from io import BytesIO, FileIO
 from pathlib import Path, PurePosixPath
 from typing import (
@@ -21,11 +21,13 @@ from typing import (
 )
 from urllib.parse import urlparse
 
+from typing_extensions import Self
+
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
 from ..exception import ExecutionError
-from .async_utils import TaskContext, retry
+from .async_utils import TaskContext, asyncnullcontext, retry
 from .hash_utils import UploadHashes, get_upload_hashes
 from .http_utils import ClientSessionRegistry
 from .logger import logger
@@ -54,10 +56,60 @@ DEFAULT_SEGMENT_CHUNK_SIZE = 2**24
 # TODO(dano): remove this once we stop requiring md5 for blobs
 MULTIPART_UPLOAD_THRESHOLD = 1024**3
 
+# Memory budget for multipart uploads.
+MULTIPART_INFLIGHT_BYTES_MAX = 2 * 1024**3  # 2 GiB
+MULTIPART_INFLIGHT_BYTES_MIN = 256 * 1024 * 1024  # 256 MiB
+MULTIPART_INFLIGHT_MEMORY_FRACTION = 0.5  # 50% of RAM
+
+
 # For block based storage like volumefs2: the size of a block
 BLOCK_SIZE: int = 8 * 1024 * 1024
 
 
+class _ByteBudget:
+    """Limits total in-flight bytes across concurrent operations."""
+
+    def __init__(self, total: int):
+        self._total = total
+        self._available = total
+        self._cond = asyncio.Condition()
+
+    @classmethod
+    def from_system_memory(cls) -> Self:
+        return cls(_get_multipart_inflight_budget())
+
+    @asynccontextmanager
+    async def acquire(self, n: int):
+        async with self._cond:
+            # Wait until enough budget is free. If a single part exceeds the
+            # total budget, allow it through once nothing else is in-flight.
+            while self._available < min(n, self._total):
+                await self._cond.wait()
+            self._available -= n
+        try:
+            yield
+        finally:
+            async with self._cond:
+                self._available += n
+                self._cond.notify_all()
+
+
+def _get_multipart_inflight_budget() -> int:
+    """Return a byte budget for concurrent part uploads, scaled to available system memory."""
+    try:
+        import psutil
+
+        available = psutil.virtual_memory().available
+    except Exception:
+        try:
+            available = os.sysconf("SC_AVPHYS_PAGES") * os.sysconf("SC_PAGE_SIZE")
+        except (AttributeError, ValueError, OSError):
+            return MULTIPART_INFLIGHT_BYTES_MIN
+
+    budget = int(available * MULTIPART_INFLIGHT_MEMORY_FRACTION)
+    return max(MULTIPART_INFLIGHT_BYTES_MIN, min(budget, MULTIPART_INFLIGHT_BYTES_MAX))
+
+
 @retry(n_attempts=3, base_delay=0.3, attempt_timeout=None)
 async def _upload_to_s3_url(
     upload_url,
@@ -116,6 +168,7 @@ async def perform_multipart_upload(
     completion_url: str,
     upload_chunk_size: int = DEFAULT_SEGMENT_CHUNK_SIZE,
     progress_report_cb: Optional[Callable] = None,
+    byte_budget: Optional[_ByteBudget] = None,
 ) -> None:
     from .bytes_io_segment_payload import BytesIOSegmentPayload
 
@@ -133,6 +186,14 @@ async def perform_multipart_upload(
         filename = data_file.name
         data_file_readers = [open(filename, "rb") for _ in range(len(part_urls))]
 
+    async def _upload_part(part_url: str, part_payload: "BytesIOSegmentPayload") -> str:
+        # BytesIOSegmentPayload limits the amount of memory used, but here we
+        # acquire some extra for additional copies for various buffers based on
+        # empirical testing.
+        bytes_to_acquire = 4 * part_payload.chunk_size
+        async with byte_budget.acquire(bytes_to_acquire) if byte_budget else asyncnullcontext():
+            return await _upload_to_s3_url(part_url, payload=part_payload, content_type=None)
+
     for part_number, (data_file_rdr, part_url) in enumerate(zip(data_file_readers, part_urls), start=1):
         part_length_bytes = min(num_bytes_left, max_part_size)
         part_payload = BytesIOSegmentPayload(
@@ -142,7 +203,7 @@ async def perform_multipart_upload(
             chunk_size=upload_chunk_size,
             progress_report_cb=progress_report_cb,
         )
-        upload_coros.append(_upload_to_s3_url(part_url, payload=part_payload, content_type=None))
+        upload_coros.append(_upload_part(part_url, part_payload))
         num_bytes_left -= part_length_bytes
         file_offset += part_length_bytes
 
@@ -211,7 +272,11 @@ async def _blob_upload_with_fallback(
 
 
 async def _blob_upload(
-    upload_hashes: UploadHashes, data: Union[bytes, BinaryIO], stub, progress_report_cb: Optional[Callable] = None
+    upload_hashes: UploadHashes,
+    data: Union[bytes, BinaryIO],
+    stub,
+    progress_report_cb: Optional[Callable] = None,
+    byte_budget: Optional[_ByteBudget] = None,
 ) -> tuple[str, bool, int]:
     if isinstance(data, bytes):
         data = BytesIO(data)
@@ -236,6 +301,7 @@ async def _blob_upload(
                 completion_url=part.completion_url,
                 upload_chunk_size=DEFAULT_SEGMENT_CHUNK_SIZE,
                 progress_report_cb=progress_report_cb,
+                byte_budget=byte_budget,
             )
 
         blob_id, r2_failed, r2_throughput_bytes_s = await _blob_upload_with_fallback(
@@ -304,9 +370,10 @@ async def blob_upload_file(
     progress_report_cb: Optional[Callable] = None,
     sha256_hex: Optional[str] = None,
     md5_hex: Optional[str] = None,
+    byte_budget: Optional[_ByteBudget] = None,
 ) -> str:
     upload_hashes = get_upload_hashes(file_obj, sha256_hex=sha256_hex, md5_hex=md5_hex)
-    blob_id, _, _ = await _blob_upload(upload_hashes, file_obj, stub, progress_report_cb)
+    blob_id, _, _ = await _blob_upload(upload_hashes, file_obj, stub, progress_report_cb, byte_budget=byte_budget)
     return blob_id
 
 
@@ -650,7 +717,7 @@ def use_md5(url: str) -> bool:
     host = urlparse(url).netloc.split(":")[0]
     if host.endswith(".amazonaws.com") or host.endswith(".r2.cloudflarestorage.com"):
         return True
-    elif host in ["127.0.0.1", "localhost", "172.21.0.1"]:
+    elif host in ["127.0.0.1", "localhost", "172.20.0.1", "172.21.0.1"]:
         return False
     else:
         raise Exception(f"Unknown S3 host: {host}")

modal-1.4.3.dev4/modal/cli/_help.py

@@ -0,0 +1,264 @@
+# Copyright Modal Labs 2026
+"""Custom help formatting for the Modal CLI."""
+
+from __future__ import annotations
+
+import inspect
+import os
+import sys
+from typing import Any, Optional
+
+import click
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+_HEADING_STYLE = "bold bright_green"
+_COMMAND_NAME_STYLE = ""
+_COMMAND_DESC_STYLE = "dim"
+_OPTION_FLAG_STYLE = "green"
+_OPTION_METAVAR_STYLE = "dim"
+_ERROR_STYLE = "red"
+
+_MAX_HELP_WIDTH = 80
+
+
+def use_rich_style() -> bool:
+    """Whether help output should be rendered in the rich style."""
+    env = os.environ.get("MODAL_RICH_CLI")  # TODO move to config
+    if env in ("0", "1"):
+        return env == "1"
+    return sys.stdout.isatty()
+
+
+def _make_console(file: Optional[Any] = None) -> Console:
+    return Console(file=file, highlight=False)
+
+
+def _render_usage(cmd: click.Command, ctx: click.Context, console: Console) -> None:
+    pieces = " ".join(cmd.collect_usage_pieces(ctx))
+    usage = Text()
+    usage.append("Usage: ", style=_HEADING_STYLE)
+    usage.append(f"{ctx.command_path} {pieces}".rstrip())
+    console.print(usage)
+    console.print()
+
+
+def _render_help_text(cmd: click.Command, console: Console) -> None:
+    text = cmd.help or cmd.short_help or ""
+    if not text:
+        return
+    console.print(Padding(Markdown(inspect.cleandoc(text)), (0, 2)))
+    console.print()
+
+
+def _option_label(param: click.Parameter, ctx: click.Context) -> Text:
+    text = Text()
+    for i, opt in enumerate(param.opts):
+        if i > 0:
+            text.append(", ")
+        text.append(opt, style=_OPTION_FLAG_STYLE)
+    if param.secondary_opts:
+        text.append(" / ")
+        for i, opt in enumerate(param.secondary_opts):
+            if i > 0:
+                text.append(", ")
+            text.append(opt, style=_OPTION_FLAG_STYLE)
+    if not getattr(param, "is_flag", False) and not getattr(param, "count", False):
+        text.append(" ")
+        text.append(param.make_metavar(ctx), style=_OPTION_METAVAR_STYLE)
+    return text
+
+
+def _render_options(cmd: click.Command, ctx: click.Context, console: Console) -> None:
+    rows: list[tuple[Text, str]] = []
+    for param in cmd.get_params(ctx):
+        rec = param.get_help_record(ctx)
+        if rec is None:  # skips arguments and hidden options
+            continue
+        rows.append((_option_label(param, ctx), rec[1] or ""))
+    if not rows:
+        return
+
+    console.print(Text("Options", style=_HEADING_STYLE))
+    table = Table(box=None, show_header=False, pad_edge=False, padding=(0, 2))
+    table.add_column(no_wrap=True)  # styling lives in the Text cells
+    table.add_column(overflow="fold")
+    for label, help_str in rows:
+        table.add_row(label, help_str)
+    console.print(table)
+    console.print()
+
+
+def _render_epilog(cmd: click.Command, console: Console) -> None:
+    if cmd.epilog:
+        console.print(cmd.epilog)
+        console.print()
+
+
+def _group_commands_by_panel(group: click.Group) -> dict[str, list[tuple[str, click.Command]]]:
+    """Bucket visible subcommands, preserving registration order."""
+    panels: dict[str, list[tuple[str, click.Command]]] = {}
+    for name, sub in group.commands.items():
+        if sub.hidden:
+            continue
+        panels.setdefault(getattr(sub, "panel", None) or "Commands", []).append((name, sub))
+    return panels
+
+
+def _render_commands(group: click.Group, console: Console) -> None:
+    panels = _group_commands_by_panel(group)
+    if not panels:
+        return
+
+    # We want the name / description columns to be the same widths across groups
+    name_width = max(len(name) for items in panels.values() for name, _ in items)
+    table_width = min(_MAX_HELP_WIDTH, console.width)
+
+    for panel_name, items in panels.items():
+        console.print(Text(panel_name.ljust(table_width), style=f"{_HEADING_STYLE} underline"))
+        _render_command_table(console, items, name_width, table_width)
+        console.print()
+
+
+def build_command_table(name_width: int, table_width: Optional[int] = None) -> Table:
+    kwargs: dict[str, Any] = {"box": None, "show_header": False, "pad_edge": False, "padding": (0, 2)}
+    if table_width is not None:
+        kwargs["width"] = table_width
+    table = Table(**kwargs)
+    table.add_column(style=_COMMAND_NAME_STYLE, no_wrap=True, width=name_width)
+    # ratio=1 claims any extra width for the description column so col1 stays
+    # fixed at name_width across panels — otherwise Rich distributes slack into
+    # both columns and the name column grows in panels with shorter content.
+    table.add_column(style=_COMMAND_DESC_STYLE, overflow="fold", ratio=1)
+    return table
+
+
+def _render_command_table(
+    console: Console,
+    items: list[tuple[str, click.Command]],
+    name_width: int,
+    table_width: int,
+) -> None:
+    table = build_command_table(name_width, table_width)
+    for name, sub in items:
+        table.add_row(name, sub.get_short_help_str(limit=80))
+    console.print(table)
+
+
+# -- Public Command / Group subclasses ---------------------------------------
+
+
+class ModalCommand(click.Command):
+    """click.Command that renders --help with custom rich output."""
+
+    def __init__(self, *args: Any, panel: Optional[str] = None, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.panel = panel
+
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        if not use_rich_style():
+            return super().format_help(ctx, formatter)
+        console = _make_console()
+        with console.capture() as capture:
+            _render_usage(self, ctx, console)
+            _render_help_text(self, console)
+            _render_options(self, ctx, console)
+            _render_epilog(self, console)
+        formatter.write(capture.get())
+
+
+class ModalGroup(click.Group):
+    """click.Group whose subcommands and subgroups inherit `ModalCommand`."""
+
+    command_class = ModalCommand
+    group_class = type  # nested @group.group() reuses the enclosing class
+
+    def __init__(self, *args: Any, panel: Optional[str] = None, **kwargs: Any) -> None:
+        # Default to showing help when a group is invoked with no subcommand.
+        # Callers can opt out by passing no_args_is_help=False explicitly.
+        kwargs.setdefault("no_args_is_help", True)
+        super().__init__(*args, **kwargs)
+        self.panel = panel
+
+    def add_command(
+        self,
+        cmd: click.Command,
+        name: Optional[str] = None,
+        *,
+        panel: Optional[str] = None,
+        hidden: Optional[bool] = None,
+    ) -> None:
+        super().add_command(cmd, name)
+        if panel is not None:
+            cmd.panel = panel  # type: ignore[attr-defined]
+        if hidden is not None:
+            cmd.hidden = hidden
+
+    def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        # Replaces click's single flat "Commands:" section with one section per
+        # panel so the simple-style help output still preserves grouping.
+        for panel_name, items in _group_commands_by_panel(self).items():
+            rows = [(name, sub.get_short_help_str(limit=80)) for name, sub in items]
+            with formatter.section(panel_name):
+                formatter.write_dl(rows)
+
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        if not use_rich_style():
+            return super().format_help(ctx, formatter)
+        console = _make_console()
+        with console.capture() as capture:
+            _render_usage(self, ctx, console)
+            _render_help_text(self, console)
+            _render_options(self, ctx, console)
+            _render_commands(self, console)
+            _render_epilog(self, console)
+        formatter.write(capture.get())
+
+
+# -- Error rendering ---------------------------------------------------------
+
+
+def _render_click_exception(exc: click.ClickException, file: Any) -> None:
+    console = _make_console(file if file is not None else sys.stderr)
+    title = "Error"
+
+    if isinstance(exc, click.UsageError) and exc.ctx is not None:
+        ctx = exc.ctx
+        console.print(ctx.get_usage())
+        if ctx.command.get_help_option(ctx) is not None:
+            option = ctx.help_option_names[0] if ctx.help_option_names else "--help"
+            console.print(f"Try [bold]'{ctx.command_path} {option}'[/bold] for help.")
+
+    console.print(
+        Panel(
+            Text(exc.format_message()),
+            title=title,
+            title_align="left",
+            border_style=_ERROR_STYLE,
+            expand=True,
+        )
+    )
+
+
+_orig_click_show = click.ClickException.show
+_orig_usage_show = click.UsageError.show
+
+
+def _click_show(self: click.ClickException, file: Any = None) -> None:
+    if not use_rich_style():
+        return _orig_click_show(self, file)
+    _render_click_exception(self, file)
+
+
+def _usage_show(self: click.UsageError, file: Any = None) -> None:
+    if not use_rich_style():
+        return _orig_usage_show(self, file)
+    _render_click_exception(self, file)
+
+
+click.ClickException.show = _click_show  # type: ignore[method-assign]
+click.UsageError.show = _usage_show  # type: ignore[method-assign]

{modal-1.4.3.dev2 → modal-1.4.3.dev4}/modal/cli/_traceback.py

@@ -154,9 +154,8 @@ def setup_rich_traceback() -> None:
     import click
     import grpclib
     import synchronicity
-    import typer
 
-    install(suppress=[synchronicity, grpclib, click, typer], extra_lines=1)
+    install(suppress=[synchronicity, grpclib, click], extra_lines=1)
 
 
 def highlight_modal_warnings() -> None:

{modal-1.4.3.dev2 → modal-1.4.3.dev4}/modal/cli/app.py

@@ -8,11 +8,9 @@ from typing import Optional, Union, get_args
 
 import click
 import rich
-import typer
 from click import UsageError
 from rich.table import Column
 from rich.text import Text
-from typer import Argument
 
 from modal._object import _get_environment_name
 from modal._traceback import print_server_warnings
@@ -27,20 +25,18 @@ from modal_proto import api_pb2
 
 from .._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
 from .._utils.time_utils import locale_tz, timestamp_to_localized_str
+from ._help import ModalGroup
 from .utils import (
-    ENV_OPTION,
-    YES_OPTION,
     confirm_or_suggest_yes,
     display_table,
+    env_option,
     fetch_app_logs,
     stream_app_logs,
     tail_app_logs,
+    yes_option,
 )
 
-APP_IDENTIFIER = Argument("", help="App name or ID")
-NAME_OPTION = typer.Option("", "-n", "--name", help="Deprecated: Pass App name as a positional argument")
-
-app_cli = typer.Typer(name="app", help="Manage deployed and running apps.", no_args_is_help=True)
+app_cli = ModalGroup(name="app", help="Manage deployed and running apps.")
 
 APP_STATE_TO_MESSAGE = {
     api_pb2.APP_STATE_DEPLOYED: Text("deployed", style="green"),
@@ -101,9 +97,11 @@ async def resolve_app_identifier(
 
 
 @app_cli.command("list")
+@env_option
+@click.option("--json", is_flag=True, default=False)
 @synchronizer.create_blocking
-async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
-    """List Modal apps that are currently deployed/running or recently stopped."""
+async def list_(env: Optional[str] = None, json: bool = False):
+    """List Apps that are running, deployed or recently stopped."""
     env = ensure_env(env)
     client = await _Client.from_env()
 
@@ -176,38 +174,43 @@ _SOURCE_OPTIONS = {
 
 
 @app_cli.command("logs", no_args_is_help=True)
+@click.argument("app_identifier")
+@click.option("-f", "--follow", is_flag=True, default=False, help="Stream log output until App stops")
+@click.option(
+    "--since",
+    default=None,
+    help="Start of time range. Accepts ISO 8601 datetime or relative time, e.g. '1d' (1 day ago), '2h', '30m', etc.",
+)
+@click.option("--until", default=None, help="End of time range; accepts same argument types as --since")
+@click.option("-n", "--tail", default=None, type=int, help="Show only the last N log entries")
+@click.option("--search", default=None, help="Filter by search text")
+@click.option("--function", "function_id", default="", help="Filter by Function ID (fu-*)")
+@click.option("--function-call", "function_call_id", default="", help="Filter by FunctionCall ID (fc-*)")
+@click.option("--container", "container_id", default="", help="Filter by Container ID (ta-*)")
+@click.option("-s", "--source", default=None, help="Filter by source: 'stdout', 'stderr', or 'system'")
+@click.option("--timestamps", is_flag=True, default=False, help="Prefix each line with its timestamp")
+@click.option("--show-function-id", is_flag=True, default=False, help="Prefix each line with its Function ID")
+@click.option("--show-function-call-id", is_flag=True, default=False, help="Prefix each line with its FunctionCall ID")
+@click.option("--show-container-id", is_flag=True, default=False, help="Prefix each line with its Container ID")
+@env_option
 @synchronizer.create_blocking
 async def logs(
-    app_identifier: str = APP_IDENTIFIER,
-    follow: bool = typer.Option(False, "-f", "--follow", help="Stream log output until App stops"),
-    since: Optional[str] = typer.Option(
-        None,
-        "--since",
-        help=(
-            "Start of time range. Accepts ISO 8601 datetime or relative time, e.g. '1d' (1 day ago), '2h', '30m', etc."
-        ),
-    ),
-    until: Optional[str] = typer.Option(
-        None,
-        "--until",
-        help="End of time range; accepts same argument types as --since",
-    ),
-    tail: Optional[int] = typer.Option(None, "--tail", "-n", help="Show only the last N log entries"),
-    search: Optional[str] = typer.Option(None, "--search", help="Filter by search text"),
-    function_id: Optional[str] = typer.Option("", "--function", help="Filter by Function ID (fu-*)"),
-    function_call_id: Optional[str] = typer.Option("", "--function-call", help="Filter by FunctionCall ID (fc-*)"),
-    container_id: Optional[str] = typer.Option("", "--container", help="Filter by Container ID (ta-*)"),
-    source: Optional[str] = typer.Option(
-        None, "--source", "-s", help="Filter by source: 'stdout', 'stderr', or 'system'"
-    ),
-    timestamps: bool = typer.Option(False, "--timestamps", help="Prefix each line with its timestamp"),
-    show_function_id: bool = typer.Option(False, "--show-function-id", help="Prefix each line with its Function ID"),
-    show_function_call_id: bool = typer.Option(
-        False, "--show-function-call-id", help="Prefix each line with its FunctionCall ID"
-    ),
-    show_container_id: bool = typer.Option(False, "--show-container-id", help="Prefix each line with its Container ID"),
+    app_identifier: str,
+    follow: bool = False,
+    since: Optional[str] = None,
+    until: Optional[str] = None,
+    tail: Optional[int] = None,
+    search: Optional[str] = None,
+    function_id: str = "",
+    function_call_id: str = "",
+    container_id: str = "",
+    source: Optional[str] = None,
+    timestamps: bool = False,
+    show_function_id: bool = False,
+    show_function_call_id: bool = False,
+    show_container_id: bool = False,
     *,
-    env: Optional[str] = ENV_OPTION,
+    env: Optional[str] = None,
 ):
     """Fetch or stream App logs.
 
@@ -265,8 +268,6 @@ async def logs(
     ```
 
     """
-    if not app_identifier:
-        raise UsageError("Either an App ID or name must be provided.")
 
     if follow and (since or until or tail):
         raise UsageError("--follow cannot be combined with --since, --until, or --tail.")
@@ -350,12 +351,15 @@ async def logs(
 
 
 @app_cli.command("rollback", no_args_is_help=True, context_settings={"ignore_unknown_options": True})
+@click.argument("app_identifier")
+@click.argument("version", default="")
+@env_option
 @synchronizer.create_blocking
 async def rollback(
-    app_identifier: str = APP_IDENTIFIER,
-    version: str = typer.Argument("", help="Target version for rollback."),
+    app_identifier: str,
+    version: str = "",
     *,
-    env: Optional[str] = ENV_OPTION,
+    env: Optional[str] = None,
 ):
     """Redeploy a previous version of an App.
 
@@ -404,16 +408,20 @@ async def rollback(
 
 
 @app_cli.command("rollover", no_args_is_help=True)
+@click.argument("app_identifier")
+@click.option(
+    "--strategy",
+    default="rolling",
+    type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
+    help="Strategy for rollover",
+)
+@env_option
 @synchronizer.create_blocking
 async def rollover(
-    app_identifier: str = APP_IDENTIFIER,
+    app_identifier: str,
+    strategy: str = "rolling",
     *,
-    strategy: str = typer.Option(
-        "rolling",
-        help="Strategy for rollover",
-        click_type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
-    ),
-    env: Optional[str] = ENV_OPTION,
+    env: Optional[str] = None,
 ):
     """Redeploy an App to get new containers without code changes.
 
@@ -467,12 +475,15 @@ async def rollover(
 
 
 @app_cli.command("stop", no_args_is_help=True)
+@click.argument("app_identifier")
+@yes_option
+@env_option
 @synchronizer.create_blocking
 async def stop(
-    app_identifier: str = APP_IDENTIFIER,
+    app_identifier: str,
     *,
-    yes: bool = YES_OPTION,
-    env: Optional[str] = ENV_OPTION,
+    yes: bool = False,
+    env: Optional[str] = None,
 ):
     """Permanently stop an App and terminate its running containers."""
     env = ensure_env(env)
@@ -510,11 +521,14 @@ async def stop(
 
 
 @app_cli.command("history", no_args_is_help=True)
+@click.argument("app_identifier")
+@env_option
+@click.option("--json", is_flag=True, default=False)
 @synchronizer.create_blocking
 async def history(
-    app_identifier: str = APP_IDENTIFIER,
+    app_identifier: str,
     *,
-    env: Optional[str] = ENV_OPTION,
+    env: Optional[str] = None,
     json: bool = False,
 ):
     """Show an App's deployment history.
@@ -588,11 +602,13 @@ async def history(
 
 
 @app_cli.command("dashboard", no_args_is_help=True)
+@click.argument("app_identifier")
+@env_option
 @synchronizer.create_blocking
 async def dashboard(
-    app_identifier: str = APP_IDENTIFIER,
+    app_identifier: str,
     *,
-    env: Optional[str] = ENV_OPTION,
+    env: Optional[str] = None,
 ):
     """Open an App's dashboard page in your web browser.