modAL 1.4.2__tar.gz → 1.4.2.dev1__tar.gz

{modal-1.4.2 → modal-1.4.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.2
+Version: 1.4.2.dev1
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_functions.py

@@ -700,6 +700,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ephemeral_disk: Optional[int] = None,
         include_source: bool = True,
         experimental_options: Optional[dict[str, str]] = None,
+        _experimental_proxy_ip: Optional[str] = None,
         restrict_output: bool = False,
         http_config: Optional[api_pb2.HTTPConfig] = None,
     ) -> "_Function":
@@ -1040,6 +1041,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     # ---
                     _experimental_group_size=cluster_size or 0,  # Experimental: Clustered functions
                     _experimental_concurrent_cancellations=True,
+                    _experimental_proxy_ip=_experimental_proxy_ip,
                     # --- These are deprecated in favor of autoscaler_settings
                     warm_pool_size=min_containers or 0,
                     concurrency_limit=max_containers or 0,
@@ -1082,6 +1084,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         _experimental_group_size=function_definition._experimental_group_size,
                         _experimental_buffer_containers=function_definition._experimental_buffer_containers,
                         _experimental_custom_scaling=function_definition._experimental_custom_scaling,
+                        _experimental_proxy_ip=function_definition._experimental_proxy_ip,
                         snapshot_debug=function_definition.snapshot_debug,
                         runtime_perf_record=function_definition.runtime_perf_record,
                         function_schema=function_schema,

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_runtime/asgi.py

@@ -474,11 +474,8 @@ async def _proxy_lifespan_request(base_url, scope, receive, send) -> None:
                     auto_decompress=False,
                     read_bufsize=1024 * 1024,  # 1 MiB
                     connector=aiohttp.TCPConnector(
-                        limit=1000,  # 100 is the default max, but 1000 is the max for `@modal.concurrent`.
-                        # Disable keep-alive connection reuse to avoid ServerDisconnectedError
-                        # from stale pooled connections.
-                        force_close=True,
-                    ),
+                        limit=1000
+                    ),  # 100 is the default max, but 1000 is the max for `@modal.concurrent`.
                     # Note: these values will need to be kept in sync.
                     **(
                         # These options were introduced in aiohttp 3.9, and we can remove the

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_utils/grpc_utils.py

@@ -216,11 +216,7 @@ def create_channel(
         for k, v in metadata.items():
             event.metadata[k] = v
 
-        idempotency_key = typing.cast(Optional[str], event.metadata.get("x-idempotency-key"))
-        if idempotency_key is None:
-            logger.debug(f"Sending request to {event.method_name}")
-        else:
-            logger.debug(f"Sending request to {event.method_name} ({idempotency_key[:8]})")
+        logger.debug(f"Sending request to {event.method_name}")
 
     grpclib.events.listen(channel, grpclib.events.SendRequest, send_request)
 
@@ -292,14 +288,12 @@ def process_exception_before_retry(
     n_retries: int,
     delay: float,
     idempotency_key: str,
-    rpc_elapsed: float,
 ):
     """Process exception before retry, used by `_retry_transient_errors`."""
     with suppress_tb_frame():
         if final_attempt:
             logger.debug(
-                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
-                f"for {fn_name} ({idempotency_key[:8]})"
+                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})"
             )
             if isinstance(exc, OSError):
                 raise ConnectionError(str(exc))
@@ -316,10 +310,7 @@ def process_exception_before_retry(
             # we handle in the retry logic once we drop this check!
             raise exc
 
-    logger.debug(
-        f"Retryable failure {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
-        f"for {fn_name} ({idempotency_key[:8]})"
-    )
+    logger.debug(f"Retryable failure {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})")
 
 
 async def _retry_transient_errors(
@@ -382,7 +373,6 @@ async def _retry_transient_errors(
         else:
             timeout = None
 
-        attempt_started_at = time.monotonic()
         try:
             with suppress_tb_frame():
                 return await fn_callable(req, metadata=attempt_metadata, timeout=timeout)
@@ -419,13 +409,7 @@ async def _retry_transient_errors(
 
                 with suppress_tb_frame():
                     process_exception_before_retry(
-                        exc,
-                        final_attempt,
-                        fn.name,
-                        n_retries,
-                        server_delay,
-                        idempotency_key,
-                        time.monotonic() - attempt_started_at,
+                        exc, final_attempt, fn.name, n_retries, server_delay, idempotency_key
                     )
 
                 now = time.time()
@@ -454,15 +438,7 @@ async def _retry_transient_errors(
                 final_attempt = False
 
             with suppress_tb_frame():
-                process_exception_before_retry(
-                    exc,
-                    final_attempt,
-                    fn.name,
-                    n_retries,
-                    delay,
-                    idempotency_key,
-                    time.monotonic() - attempt_started_at,
-                )
+                process_exception_before_retry(exc, final_attempt, fn.name, n_retries, delay, idempotency_key)
 
             n_retries += 1
 

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_utils/rand_pb_testing.py

@@ -52,9 +52,8 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
         if hasattr(field, "is_repeated"):
             is_repeated = field.is_repeated  # type: ignore
         else:
-            is_repeated = field.label == FieldDescriptor.LABEL_REPEATED  # type: ignore[attr-defined]
+            is_repeated = field.label == FieldDescriptor.LABEL_REPEATED
         if is_message:
-            assert field.message_type is not None
             msg_field = getattr(msg, field.name)
             if is_repeated:
                 num = rand.randint(0, 2)
@@ -65,7 +64,6 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
                 _fill(msg_field, field.message_type, rand)
         else:
             if field.type == FieldDescriptor.TYPE_ENUM:
-                assert field.enum_type is not None
                 enum_values = [x.number for x in field.enum_type.values]
                 generator = lambda rand: rand.choice(enum_values)  # noqa: E731
 

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_utils/sandbox_fs_utils.py

@@ -18,7 +18,6 @@ from ..exception import (
     SandboxFilesystemIsADirectoryError,
     SandboxFilesystemNotADirectoryError,
     SandboxFilesystemNotFoundError,
-    SandboxFilesystemPathAlreadyExistsError,
     SandboxFilesystemPermissionError,
     ServiceError,
 )
@@ -189,42 +188,6 @@ def raise_remove_error(returncode: int, stderr: Union[str, bytes], remote_path:
     raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
 
 
-def make_make_directory_command(remote_path: str, create_parents: bool) -> str:
-    """Build the JSON command string for a MakeDirectory operation.
-
-    The returned JSON must match the `Command` enum in the modal-sandbox-fs-tools
-    Rust crate (crates/modal-sandbox-fs-tools/src/lib.rs). Treat changes to
-    this schema like protobuf changes: fields must not be removed or renamed,
-    only added with backwards-compatible defaults.
-    """
-    return json.dumps({"MakeDirectory": {"path": remote_path, "parents": create_parents}})
-
-
-def raise_make_directory_error(returncode: int, stderr: Union[str, bytes], remote_path: str) -> NoReturn:
-    if payload := try_parse_error_payload(stderr):
-        logger.debug(
-            f"sandbox-fs-tools make_directory error: path={remote_path}, "
-            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
-        )
-        if payload.error_kind == "NotFound":
-            raise SandboxFilesystemNotFoundError(f"{payload.message}: {remote_path}")
-        if payload.error_kind == "PathAlreadyExists":
-            raise SandboxFilesystemPathAlreadyExistsError(f"{payload.message}: {remote_path}")
-        if payload.error_kind == "NotDirectory":
-            raise SandboxFilesystemNotADirectoryError(f"{payload.message}: {remote_path}")
-        if payload.error_kind == "PermissionDenied":
-            raise SandboxFilesystemPermissionError(f"{payload.message}: {remote_path}")
-        if payload.error_kind == "NotSupported":
-            raise InvalidError(
-                f"{payload.message}: {remote_path} - this operation is not supported for CloudBucketMounts"
-            )
-        raise SandboxFilesystemError(payload.message)
-
-    if stderr_text := _stderr_to_text(stderr):
-        logger.debug(f"Unstructured modal-sandbox-fs-tools stderr: {stderr_text}")
-    raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
-
-
 def validate_absolute_remote_path(remote_path: str, operation: str) -> None:
     if not PurePosixPath(remote_path).is_absolute():
         raise InvalidError(f"Sandbox.filesystem.{operation}() currently only supports absolute remote_path values")

{modal-1.4.2 → modal-1.4.2.dev1}/modal/_utils/task_command_router_client.py

@@ -126,11 +126,8 @@ async def fetch_command_router_access_v2(
     server_client, sandbox_id: str
 ) -> api_pb2.SandboxGetCommandRouterAccessResponse:
     """Fetch direct command router access info from Modal server for a V2 sandbox."""
-    assert server_client._auth_token_manager
-    auth_token = await server_client._auth_token_manager.get_token()
     return await server_client.stub.SandboxGetCommandRouterAccess(
         api_pb2.SandboxGetCommandRouterAccessRequest(sandbox_id=sandbox_id),
-        metadata=[("x-modal-auth-token", auth_token)],
     )
 
 
@@ -505,8 +502,7 @@ class TaskCommandRouterClient:
                 jwt, url = v1_resp.jwt, v1_resp.url
 
             # Ensure the server URL remains stable for the lifetime of this client.
-            if url != self._server_url:
-                logger.warning("Task router URL changed during session")
+            assert url == self._server_url, "Task router URL changed during session"
             self._jwt = jwt
             self._jwt_exp = _parse_jwt_expiration(jwt)
 
@@ -620,12 +616,6 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskMountDirectory, request)
             )
 
-    async def unmount_image(self, request: sr_pb2.TaskUnmountDirectoryRequest):
-        with grpc_error_converter():
-            return await call_with_retries_on_transient_errors(
-                lambda: self._call_with_auth_retry(self._stub.TaskUnmountDirectory, request)
-            )
-
     async def snapshot_directory(
         self, request: sr_pb2.TaskSnapshotDirectoryRequest
     ) -> sr_pb2.TaskSnapshotDirectoryResponse:

{modal-1.4.2 → modal-1.4.2.dev1}/modal/app.py

@@ -753,6 +753,7 @@ class _App:
         include_source: Optional[bool] = None,
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
+        _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
         _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
         max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
@@ -913,6 +914,7 @@ class _App:
                 rdma=rdma,
                 include_source=include_source if include_source is not None else local_state.include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
+                _experimental_proxy_ip=_experimental_proxy_ip,
                 restrict_output=_experimental_restrict_output,
             )
 
@@ -966,6 +968,7 @@ class _App:
         include_source: Optional[bool] = None,  # When `False`, don't automatically add the App source to the container.
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
+        _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
         _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
         max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
@@ -1112,6 +1115,7 @@ class _App:
                 rdma=rdma,
                 include_source=include_source if include_source is not None else local_state.include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
+                _experimental_proxy_ip=_experimental_proxy_ip,
                 restrict_output=_experimental_restrict_output,
             )
 

{modal-1.4.2 → modal-1.4.2.dev1}/modal/app.pyi

@@ -497,6 +497,7 @@ class _App:
         i6pn: typing.Optional[bool] = None,
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
+        _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_restrict_output: bool = False,
         max_inputs: typing.Optional[int] = None,
     ) -> _FunctionDecoratorType:
@@ -544,6 +545,7 @@ class _App:
         i6pn: typing.Optional[bool] = None,
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
+        _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_restrict_output: bool = False,
         max_inputs: typing.Optional[int] = None,
     ) -> collections.abc.Callable[[typing.Union[CLS_T, modal._partial_function._PartialFunction]], CLS_T]:
@@ -1213,6 +1215,7 @@ class App:
         i6pn: typing.Optional[bool] = None,
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
+        _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_restrict_output: bool = False,
         max_inputs: typing.Optional[int] = None,
     ) -> _FunctionDecoratorType:
@@ -1260,6 +1263,7 @@ class App:
         i6pn: typing.Optional[bool] = None,
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
+        _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_restrict_output: bool = False,
         max_inputs: typing.Optional[int] = None,
     ) -> collections.abc.Callable[[typing.Union[CLS_T, modal.partial_function.PartialFunction]], CLS_T]:

{modal-1.4.2 → modal-1.4.2.dev1}/modal/cli/app.py

@@ -20,22 +20,13 @@ from modal._utils.async_utils import synchronizer
 from modal._utils.browser_utils import open_url_and_display
 from modal.client import _Client
 from modal.environments import ensure_env
-from modal.exception import InvalidError, NotFoundError
 from modal.output import OutputManager
 from modal.runner import DEPLOYMENT_STRATEGY_TYPE, _stop_and_wait_for_containers
 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 .utils import (
-    ENV_OPTION,
-    YES_OPTION,
-    confirm_or_suggest_yes,
-    display_table,
-    fetch_app_logs,
-    stream_app_logs,
-    tail_app_logs,
-)
+from .utils import ENV_OPTION, display_table, fetch_app_logs, get_app_id_from_name, stream_app_logs, tail_app_logs
 
 APP_IDENTIFIER = Argument("", help="App name or ID")
 NAME_OPTION = typer.Option("", "-n", "--name", help="Deprecated: Pass App name as a positional argument")
@@ -54,50 +45,12 @@ APP_STATE_TO_MESSAGE = {
 }
 
 
-async def resolve_app_identifier(
-    app_identifier: str, env: Optional[str], client: Optional[_Client] = None
-) -> tuple[str, str, api_pb2.AppLifecycle]:  # Return app_id, environment_name, lifecycle
-    """Handle an App ID or an App name and return context about the App it points at.
-
-    When a name is provided, we may retrieve either a currently deployed App or an App that
-    was recently stopped (if no other App with that name has been deployed since).
-    It is up to callers of this function to decide whether it's valid to use the App ID
-    based on the lifecycle returned and their specific operations.
-
-    Can also raise a NotFoundError if the argument matches the App ID regex but the App
-    doesn't exist on the backend, or if there is no currently deployed or recently stopped App
-    with that name.
-
-    The function also always returns a valid environment name for any name-based lookups,
-    which may reflect the server-defined default environment when the provided argument was null.
-
-    """
-    if client is None:
-        client = await _Client.from_env()
+@synchronizer.create_blocking
+async def get_app_id(app_identifier: str, env: Optional[str], client: Optional[_Client] = None) -> str:
+    """Resolve an app_identifier that may be a name or an ID into an ID."""
     if re.match(r"^ap-[a-zA-Z0-9]{22}$", app_identifier):
-        # Identifier is an App ID. This is unambiguous, so we can make the request and return
-        # the lifecycle. AppGetLifecycle will raise NotFoundError if the ID doesn't point at an App.
-        # If we return, it's a real App, but it's up to the caller to decide what to do based on
-        # the App's current state as conveyed by the lifecycle. We do propagate a NotFoundError
-        # from the server if the App ID doesn't actually exist.
-        request = api_pb2.AppGetLifecycleRequest(app_id=app_identifier)
-        resp = await client.stub.AppGetLifecycle(request)
-        return app_identifier, "", resp.lifecycle
-    else:
-        # Identifier is treated as a name, which may or may not point at a currently deployed App
-        # (inside a specific environment)
-        request = api_pb2.AppGetByDeploymentNameRequest(name=app_identifier, environment_name=env or "")
-        resp = await client.stub.AppGetByDeploymentName(request)
-        if resp.app_id:
-            # App is currently deployed
-            return resp.app_id, resp.environment_name, resp.lifecycle
-        elif resp.previous_app_id:
-            # An App with this name was recently stopped. Return the ID of the stopped App
-            # and let callers decide what to do based on the lifecycle.
-            return resp.previous_app_id, resp.environment_name, resp.lifecycle
-        else:
-            msg = f"No App with name '{app_identifier}' found in the '{resp.environment_name}' environment."
-            raise NotFoundError(msg)
+        return app_identifier
+    return await get_app_id_from_name.aio(app_identifier, env, client)
 
 
 @app_cli.command("list")
@@ -176,8 +129,7 @@ _SOURCE_OPTIONS = {
 
 
 @app_cli.command("logs", no_args_is_help=True)
-@synchronizer.create_blocking
-async def logs(
+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(
@@ -277,7 +229,7 @@ async def logs(
     if tail is not None and tail > _FETCH_LIMIT:
         raise UsageError(f"--tail value must not exceed {_FETCH_LIMIT}.")
 
-    app_id, _, _ = await resolve_app_identifier(app_identifier, env)
+    app_id = get_app_id(app_identifier, env)
 
     if source is not None:
         if source not in _SOURCE_OPTIONS:
@@ -303,7 +255,7 @@ async def logs(
     )
 
     if follow:
-        await stream_app_logs.aio(
+        stream_app_logs(
             app_id,
             task_id=container_id or "",
             show_timestamps=timestamps,
@@ -326,7 +278,7 @@ async def logs(
 
         if since and tail is None:
             # Range mode: --since without --tail fetches everything in the range.
-            await fetch_app_logs.aio(
+            fetch_app_logs(
                 app_id,
                 since_dt,
                 until_dt or now,
@@ -338,7 +290,7 @@ async def logs(
             # Tail mode: single fetch with limit.
             # --since is a hard floor, --until shifts the anchor.
             effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
-            await tail_app_logs.aio(
+            tail_app_logs(
                 app_id,
                 effective_tail,
                 show_timestamps=timestamps,
@@ -386,125 +338,29 @@ async def rollback(
     """
     env = ensure_env(env)
     client = await _Client.from_env()
-    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
-    if lifecycle.app_state != api_pb2.APP_STATE_DEPLOYED:
-        env_suffix = f" in the '{environment_name}' environment" if environment_name else ""
-        raise InvalidError(f"App '{app_identifier}' is not deployed{env_suffix}.")
-
+    app_id = await get_app_id.aio(app_identifier, env, client)
     if not version:
         version_number = -1
     else:
         if m := re.match(r"v(\d+)", version):
             version_number = int(m.group(1))
         else:
-            raise UsageError(f"Invalid version specifier: {version}")
+            raise UsageError(f"Invalid version specifer: {version}")
     req = api_pb2.AppRollbackRequest(app_id=app_id, version=version_number)
     await client.stub.AppRollback(req)
     rich.print("[green]✓[/green] Deployment rollback successful!")
 
 
-@app_cli.command("rollover", no_args_is_help=True)
-@synchronizer.create_blocking
-async def rollover(
-    app_identifier: str = APP_IDENTIFIER,
-    *,
-    strategy: str = typer.Option(
-        "rolling",
-        help="Strategy for rollover",
-        click_type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
-    ),
-    env: Optional[str] = ENV_OPTION,
-):
-    """Redeploy an App to get new containers without code changes.
-
-    A rollover replaces existing containers with fresh ones built from the same
-    App version — useful for refreshing containers without changing your code.
-    The rollover appears as a new entry in the App's deployment history.
-
-    **Examples:**
-
-    Rollover an App using a rolling deployment. Running containers are now considered
-    outdated and will be gracefully replaced by new ones.
-
-    ```
-    modal app rollover my-app
-    ```
-
-    Rollover an App by terminating any running containers. Inputs on the queue will
-    start new containers.
-
-    ```
-    modal app rollover my-app --strategy recreate
-    ```
-    """
-    env = ensure_env(env)
-    client = await _Client.from_env()
-
-    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
-    if lifecycle.app_state != api_pb2.APP_STATE_DEPLOYED:
-        env_suffix = f" in the '{environment_name}' environment" if environment_name else ""
-        raise InvalidError(f"App '{app_identifier}' is not deployed{env_suffix}.")
-
-    output_mgr = OutputManager.get()
-    output_mgr.print(f"🔨 Starting app rollover with {strategy} strategy")
-    t0 = time.monotonic()
-
-    req = api_pb2.AppRolloverRequest(app_id=app_id)
-    response = await client.stub.AppRollover(req)
-    print_server_warnings(response.server_warnings)
-
-    if strategy == "recreate":
-        try:
-            await _stop_and_wait_for_containers(client, app_id, response.deployed_at, env)
-        except Exception as exc:
-            warnings.warn(f"App updated successfully, but containers did not all terminate. {exc}", UserWarning)
-            output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")
-            sys.exit(1)
-
-    duration = time.monotonic() - t0
-    output_mgr.step_completed(f"Rollover completed in {duration:.3f}s with {strategy} strategy! 🎉")
-    output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")
-
-
 @app_cli.command("stop", no_args_is_help=True)
 @synchronizer.create_blocking
 async def stop(
     app_identifier: str = APP_IDENTIFIER,
     *,
-    yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    """Permanently stop an App and terminate its running containers."""
-    env = ensure_env(env)
+    """Stop an app."""
     client = await _Client.from_env()
-    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
-
-    if lifecycle.app_state == api_pb2.APP_STATE_STOPPED:
-        msg = "App is already stopped."
-        if lifecycle.stopped_at:
-            stopped_at = timestamp_to_localized_str(lifecycle.stopped_at)
-            verb = "Stopped" if lifecycle.stopped_by else "Finished"
-            attribution = f" by '{lifecycle.stopped_by}'" if lifecycle.stopped_by else ""
-            msg += f" ({verb} at {stopped_at}{attribution})."
-        raise SystemExit(msg)
-
-    if not yes:
-        res = await client.stub.TaskList(api_pb2.TaskListRequest(app_id=app_id))
-        num_containers = len(res.tasks)
-
-        if environment_name:
-            msg = f"Are you sure you want to stop App '{app_identifier}' in the '{environment_name}' environment?"
-        else:
-            msg = f"Are you sure you want to stop App '{app_identifier}'?"
-
-        if num_containers:
-            msg += (
-                f" This will immediately terminate {num_containers} running"
-                f" container{'s' if num_containers != 1 else ''}."
-            )
-        else:
-            msg += " No containers are currently running."
-        confirm_or_suggest_yes(msg)
+    app_id = await get_app_id.aio(app_identifier, env)
     req = api_pb2.AppStopRequest(app_id=app_id, source=api_pb2.APP_STOP_SOURCE_CLI)
     await client.stub.AppStop(req)
 
@@ -517,7 +373,7 @@ async def history(
     env: Optional[str] = ENV_OPTION,
     json: bool = False,
 ):
-    """Show an App's deployment history.
+    """Show App deployment history, for a currently deployed app
 
     **Examples:**
 
@@ -527,7 +383,7 @@ async def history(
     modal app history ap-123456
     ```
 
-    Get the history for an App based on its name:
+    Get the history for a currently deployed App based on its name:
 
     ```
     modal app history my-app
@@ -536,7 +392,7 @@ async def history(
     """
     env = ensure_env(env)
     client = await _Client.from_env()
-    app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
+    app_id = await get_app_id.aio(app_identifier, env, client)
     resp = await client.stub.AppDeploymentHistory(api_pb2.AppDeploymentHistoryRequest(app_id=app_id))
 
     columns = [
@@ -611,6 +467,66 @@ async def dashboard(
     ```
     """
     client = await _Client.from_env()
-    app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
+    app_id = await get_app_id.aio(app_identifier, env, client)
+
     url = f"https://modal.com/id/{app_id}"
     open_url_and_display(url, "App dashboard")
+
+
+@app_cli.command("rollover", no_args_is_help=True, context_settings={"ignore_unknown_options": True})
+@synchronizer.create_blocking
+async def rollover(
+    app_identifier: str = APP_IDENTIFIER,
+    *,
+    strategy: str = typer.Option(
+        "rolling",
+        help="Strategy for rollover",
+        click_type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
+    ),
+    env: Optional[str] = ENV_OPTION,
+):
+    """Rollover an App.
+
+    A rollover replaces existing containers with fresh ones built from the same
+    App version — useful for refreshing containers without changing your code.
+    The rollover appears as a new entry in the App's deployment history.
+
+    **Examples:**
+
+    Rollover an App using a rolling deployment. Running containers are now considered
+    outdated and new containers will replace them.
+
+    ```
+    modal app rollover my-app
+    ```
+
+    Rollover an App by termatining all running containers. Inputs on the queue will
+    start new containers.
+
+    ```
+    modal app rollover my-app --strategy recreate
+    ```
+    """
+    env = ensure_env(env)
+    output_mgr = OutputManager.get()
+    output_mgr.print(f"🔨 Starting app rollover with {strategy} strategy")
+    t0 = time.monotonic()
+
+    client = await _Client.from_env()
+    app_id = await get_app_id.aio(app_identifier, env, client)
+
+    req = api_pb2.AppRolloverRequest(app_id=app_id)
+    response = await client.stub.AppRollover(req)
+    print_server_warnings(response.server_warnings)
+
+    if strategy == "recreate":
+        try:
+            await _stop_and_wait_for_containers(client, app_id, response.deployed_at, env)
+        except Exception as exc:
+            warnings.warn(f"App updated successfully, but containers did not all terminate. {exc}", UserWarning)
+            output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")
+            sys.exit(1)
+
+    duration = time.monotonic() - t0
+    output_mgr.step_completed(f"Rollover completed in {duration:.3f}s with {strategy} strategy! 🎉")
+    output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")