modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/runner.py

@@ -2,28 +2,38 @@
 import asyncio
 import dataclasses
 import os
+import time
+import typing
+from collections.abc import AsyncGenerator
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, AsyncGenerator, Dict, List, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
 from grpclib import GRPCError, Status
-from rich.console import Console
 from synchronicity.async_wrap import asynccontextmanager
 
+import modal_proto.api_pb2
 from modal_proto import api_pb2
 
-from ._output import OutputManager, get_app_logs_loop, step_completed, step_progress
 from ._pty import get_pty_info
 from ._resolver import Resolver
-from ._sandbox_shell import connect_to_sandbox
-from ._utils.app_utils import is_valid_app_name
-from ._utils.async_utils import TaskContext, synchronize_api
+from ._runtime.execution_context import is_local
+from ._traceback import print_server_warnings, traceback_contains_remote_call
+from ._utils.async_utils import TaskContext, gather_cancel_on_exc, synchronize_api
+from ._utils.deprecation import deprecation_error
 from ._utils.grpc_utils import retry_transient_errors
+from ._utils.name_utils import check_object_name, is_valid_tag
 from .client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
+from .cls import _Cls
 from .config import config, logger
-from .exception import ExecutionError, InteractiveTimeoutError, InvalidError, _CliUserExecutionError
-from .execution_context import is_local
-from .object import _Object
-from .running_app import RunningApp
+from .environments import _get_environment_cached
+from .exception import InteractiveTimeoutError, InvalidError, RemoteError, _CliUserExecutionError
+from .functions import _Function
+from .object import _get_environment_name, _Object
+from .output import _get_output_manager, enable_output
+from .running_app import RunningApp, running_app_from_layout
+from .sandbox import _Sandbox
+from .secret import _Secret
+from .stream_type import StreamType
 
 if TYPE_CHECKING:
     from .app import _App
@@ -31,7 +41,10 @@ else:
     _App = TypeVar("_App")
 
 
-async def _heartbeat(client, app_id):
+V = TypeVar("V")
+
+
+async def _heartbeat(client: _Client, app_id: str) -> None:
     request = api_pb2.AppHeartbeatRequest(app_id=app_id)
     # TODO(erikbern): we should capture exceptions here
     # * if request fails: destroy the client
@@ -39,39 +52,52 @@ async def _heartbeat(client, app_id):
     await retry_transient_errors(client.stub.AppHeartbeat, request, attempt_timeout=HEARTBEAT_TIMEOUT)
 
 
-async def _init_local_app_existing(client: _Client, existing_app_id: str) -> RunningApp:
+async def _init_local_app_existing(client: _Client, existing_app_id: str, environment_name: str) -> RunningApp:
     # Get all the objects first
-    obj_req = api_pb2.AppGetObjectsRequest(app_id=existing_app_id)
-    obj_resp = await retry_transient_errors(client.stub.AppGetObjects, obj_req)
+    obj_req = api_pb2.AppGetLayoutRequest(app_id=existing_app_id)
+    obj_resp, _ = await gather_cancel_on_exc(
+        retry_transient_errors(client.stub.AppGetLayout, obj_req),
+        # Cache the environment associated with the app now as we will use it later
+        _get_environment_cached(environment_name, client),
+    )
     app_page_url = f"https://modal.com/apps/{existing_app_id}"  # TODO (elias): this should come from the backend
-    object_ids = {item.tag: item.object.object_id for item in obj_resp.items}
-    return RunningApp(existing_app_id, app_page_url=app_page_url, tag_to_object_id=object_ids)
+    return running_app_from_layout(
+        existing_app_id,
+        obj_resp.app_layout,
+        app_page_url=app_page_url,
+    )
 
 
 async def _init_local_app_new(
     client: _Client,
     description: str,
-    app_state: int,
+    app_state: int,  # ValueType
     environment_name: str = "",
-    interactive=False,
+    interactive: bool = False,
 ) -> RunningApp:
     app_req = api_pb2.AppCreateRequest(
         description=description,
         environment_name=environment_name,
-        app_state=app_state,
+        app_state=app_state,  # type: ignore
+    )
+    app_resp, _ = await gather_cancel_on_exc(  # TODO: use TaskGroup?
+        retry_transient_errors(client.stub.AppCreate, app_req),
+        # Cache the environment associated with the app now as we will use it later
+        _get_environment_cached(environment_name, client),
     )
-    app_resp = await retry_transient_errors(client.stub.AppCreate, app_req)
-    app_page_url = app_resp.app_logs_url
     logger.debug(f"Created new app with id {app_resp.app_id}")
     return RunningApp(
-        app_resp.app_id, app_page_url=app_page_url, environment_name=environment_name, interactive=interactive
+        app_resp.app_id,
+        app_page_url=app_resp.app_page_url,
+        app_logs_url=app_resp.app_logs_url,
+        interactive=interactive,
     )
 
 
 async def _init_local_app_from_name(
     client: _Client,
     name: str,
-    namespace,
+    namespace: Any,
     environment_name: str = "",
 ) -> RunningApp:
     # Look up any existing deployment
@@ -85,7 +111,7 @@ async def _init_local_app_from_name(
 
     # Grab the app
     if existing_app_id is not None:
-        return await _init_local_app_existing(client, existing_app_id)
+        return await _init_local_app_existing(client, existing_app_id, environment_name)
     else:
         return await _init_local_app_new(
             client, name, api_pb2.APP_STATE_INITIALIZING, environment_name=environment_name
@@ -95,25 +121,22 @@ async def _init_local_app_from_name(
 async def _create_all_objects(
     client: _Client,
     running_app: RunningApp,
-    indexed_objects: Dict[str, _Object],
-    new_app_state: int,
+    functions: dict[str, _Function],
+    classes: dict[str, _Cls],
     environment_name: str,
-    output_mgr: Optional[OutputManager] = None,
-):  # api_pb2.AppState.V
+) -> None:
     """Create objects that have been defined but not created on the server."""
-    if not client.authenticated:
-        raise ExecutionError("Objects cannot be created with an unauthenticated client")
-
+    indexed_objects: dict[str, _Object] = {**functions, **classes}
     resolver = Resolver(
         client,
-        output_mgr=output_mgr,
         environment_name=environment_name,
         app_id=running_app.app_id,
     )
     with resolver.display():
         # Get current objects, and reset all objects
-        tag_to_object_id = running_app.tag_to_object_id
-        running_app.tag_to_object_id = {}
+        tag_to_object_id = {**running_app.function_ids, **running_app.class_ids}
+        running_app.function_ids = {}
+        running_app.class_ids = {}
 
         # Assign all objects
         for tag, obj in indexed_objects.items():
@@ -126,7 +149,7 @@ async def _create_all_objects(
         # functions have ids assigned to them when the function is serialized.
         # Note: when handles/objs are merged, all objects will need to get ids pre-assigned
         # like this in order to be referrable within serialized functions
-        for tag, obj in indexed_objects.items():
+        async def _preload(tag, obj):
             existing_object_id = tag_to_object_id.get(tag)
             # Note: preload only currently implemented for Functions, returns None otherwise
             # this is to ensure that directly referenced functions from the global scope has
@@ -135,34 +158,60 @@ async def _create_all_objects(
             if obj.object_id is not None:
                 tag_to_object_id[tag] = obj.object_id
 
-        for tag, obj in indexed_objects.items():
+        await TaskContext.gather(*(_preload(tag, obj) for tag, obj in indexed_objects.items()))
+
+        async def _load(tag, obj):
             existing_object_id = tag_to_object_id.get(tag)
             await resolver.load(obj, existing_object_id)
-            running_app.tag_to_object_id[tag] = obj.object_id
+            if _Function._is_id_type(obj.object_id):
+                running_app.function_ids[tag] = obj.object_id
+            elif _Cls._is_id_type(obj.object_id):
+                running_app.class_ids[tag] = obj.object_id
+            else:
+                raise RuntimeError(f"Unexpected object {obj.object_id}")
+
+        await TaskContext.gather(*(_load(tag, obj) for tag, obj in indexed_objects.items()))
 
-    # Create the app (and send a list of all tagged obs)
-    # TODO(erikbern): we should delete objects from a previous version that are no longer needed
-    # We just delete them from the app, but the actual objects will stay around
-    indexed_object_ids = running_app.tag_to_object_id
-    assert indexed_object_ids == running_app.tag_to_object_id
-    all_objects = resolver.objects()
 
-    unindexed_object_ids = list(set(obj.object_id for obj in all_objects) - set(running_app.tag_to_object_id.values()))
-    req_set = api_pb2.AppSetObjectsRequest(
+async def _publish_app(
+    client: _Client,
+    running_app: RunningApp,
+    app_state: int,  # api_pb2.AppState.value
+    functions: dict[str, _Function],
+    classes: dict[str, _Cls],
+    name: str = "",  # Only relevant for deployments
+    tag: str = "",  # Only relevant for deployments
+) -> tuple[str, list[api_pb2.Warning]]:
+    """Wrapper for AppPublish RPC."""
+
+    definition_ids = {obj.object_id: obj._get_metadata().definition_id for obj in functions.values()}  # type: ignore
+
+    request = api_pb2.AppPublishRequest(
         app_id=running_app.app_id,
-        indexed_object_ids=indexed_object_ids,
-        unindexed_object_ids=unindexed_object_ids,
-        new_app_state=new_app_state,  # type: ignore
+        name=name,
+        deployment_tag=tag,
+        app_state=app_state,  # type: ignore  : should be a api_pb2.AppState.value
+        function_ids=running_app.function_ids,
+        class_ids=running_app.class_ids,
+        definition_ids=definition_ids,
     )
-    await retry_transient_errors(client.stub.AppSetObjects, req_set)
+    try:
+        response = await retry_transient_errors(client.stub.AppPublish, request)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT or exc.status == Status.FAILED_PRECONDITION:
+            raise InvalidError(exc.message)
+        raise
+
+    print_server_warnings(response.server_warnings)
+    return response.url, response.server_warnings
 
 
 async def _disconnect(
     client: _Client,
     app_id: str,
-    reason: "Optional[api_pb2.AppDisconnectReason.ValueType]" = None,
-    exc_str: Optional[str] = None,
-):
+    reason: "modal_proto.api_pb2.AppDisconnectReason.ValueType",
+    exc_str: str = "",
+) -> None:
     """Tell the server the client has disconnected for this app. Terminates all running tasks
     for ephemeral apps."""
 
@@ -175,21 +224,42 @@ async def _disconnect(
     logger.debug("App disconnected")
 
 
+async def _status_based_disconnect(client: _Client, app_id: str, exc_info: Optional[BaseException] = None):
+    """Disconnect local session of a running app, sending relevant metadata
+
+    exc_info: Exception if an exception caused the disconnect
+    """
+    if isinstance(exc_info, (KeyboardInterrupt, asyncio.CancelledError)):
+        reason = api_pb2.APP_DISCONNECT_REASON_KEYBOARD_INTERRUPT
+    elif exc_info is not None:
+        if traceback_contains_remote_call(exc_info.__traceback__):
+            reason = api_pb2.APP_DISCONNECT_REASON_REMOTE_EXCEPTION
+        else:
+            reason = api_pb2.APP_DISCONNECT_REASON_LOCAL_EXCEPTION
+    else:
+        reason = api_pb2.APP_DISCONNECT_REASON_ENTRYPOINT_COMPLETED
+    if isinstance(exc_info, _CliUserExecutionError):
+        exc_str = repr(exc_info.__cause__)
+    elif exc_info:
+        exc_str = repr(exc_info)
+    else:
+        exc_str = ""
+
+    await _disconnect(client, app_id, reason, exc_str)
+
+
 @asynccontextmanager
 async def _run_app(
     app: _App,
+    *,
     client: Optional[_Client] = None,
-    stdout=None,
-    show_progress: bool = True,
     detach: bool = False,
-    output_mgr: Optional[OutputManager] = None,
     environment_name: Optional[str] = None,
-    shell=False,
-    interactive=False,
+    interactive: bool = False,
 ) -> AsyncGenerator[_App, None]:
     """mdmd:hidden"""
     if environment_name is None:
-        environment_name = config.get("environment")
+        environment_name = typing.cast(str, config.get("environment"))
 
     if not is_local():
         raise InvalidError(
@@ -215,104 +285,130 @@ async def _run_app(
 
     if client is None:
         client = await _Client.from_env()
-    if output_mgr is None:
-        output_mgr = OutputManager(stdout, show_progress, "Running app...")
-    if shell:
-        output_mgr._visible_progress = False
+
     app_state = api_pb2.APP_STATE_DETACHED if detach else api_pb2.APP_STATE_EPHEMERAL
     running_app: RunningApp = await _init_local_app_new(
         client,
-        app.description,
-        environment_name=environment_name,
+        app.description or "",
+        environment_name=environment_name or "",
         app_state=app_state,
         interactive=interactive,
     )
-    async with app._set_local_app(client, running_app), TaskContext(grace=config["logs_timeout"]) as tc:
+
+    logs_timeout = config["logs_timeout"]
+    async with app._set_local_app(client, running_app), TaskContext(grace=logs_timeout) as tc:
         # Start heartbeats loop to keep the client alive
-        tc.infinite_loop(lambda: _heartbeat(client, running_app.app_id), sleep=HEARTBEAT_INTERVAL)
+        # we don't log heartbeat exceptions in detached mode
+        # as losing the local connection will not affect the running app
+        def heartbeat():
+            return _heartbeat(client, running_app.app_id)
+
+        tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL, log_exception=not detach)
+        logs_loop: Optional[asyncio.Task] = None
+
+        if output_mgr := _get_output_manager():
+            # Defer import so this module is rich-safe
+            # TODO(michael): The get_app_logs_loop function is itself rich-safe aside from accepting an OutputManager
+            # as an argument, so with some refactoring we could avoid the need for this deferred import.
+            from modal._output import get_app_logs_loop
+
+            with output_mgr.make_live(output_mgr.step_progress("Initializing...")):
+                initialized_msg = (
+                    f"Initialized. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+                )
+                output_mgr.print(output_mgr.step_completed(initialized_msg))
+                output_mgr.update_app_page_url(running_app.app_page_url or "ERROR:NO_APP_PAGE")
 
-        with output_mgr.ctx_if_visible(output_mgr.make_live(step_progress("Initializing..."))):
-            initialized_msg = (
-                f"Initialized. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
-            )
-            output_mgr.print_if_visible(step_completed(initialized_msg))
-            output_mgr.update_app_page_url(running_app.app_page_url)
+            # Start logs loop
 
-        # Start logs loop
-        if not shell:
-            logs_loop = tc.create_task(get_app_logs_loop(running_app.app_id, client, output_mgr))
+            logs_loop = tc.create_task(
+                get_app_logs_loop(client, output_mgr, app_id=running_app.app_id, app_logs_url=running_app.app_logs_url)
+            )
 
-        exc_info: Optional[BaseException] = None
         try:
             # Create all members
-            await _create_all_objects(
-                client, running_app, app._indexed_objects, app_state, environment_name, output_mgr=output_mgr
-            )
+            await _create_all_objects(client, running_app, app._functions, app._classes, environment_name)
 
-            # Update all functions client-side to have the output mgr
-            for obj in app.registered_functions.values():
-                obj._set_output_mgr(output_mgr)
+            # Publish the app
+            await _publish_app(client, running_app, app_state, app._functions, app._classes)
+        except asyncio.CancelledError as e:
+            # this typically happens on sigint/ctrl-C during setup (the KeyboardInterrupt happens in the main thread)
+            if output_mgr := _get_output_manager():
+                output_mgr.print("Aborting app initialization...\n")
 
-            # Update all the classes client-side to propagate output manager to their methods.
-            for obj in app.registered_classes.values():
-                obj._set_output_mgr(output_mgr)
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
+        except BaseException as e:
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
 
+        try:
             # Show logs from dynamically created images.
             # TODO: better way to do this
-            output_mgr.enable_image_logs()
+            if output_mgr := _get_output_manager():
+                output_mgr.enable_image_logs()
 
             # Yield to context
-            if shell:
-                yield app
-            else:
+            if output_mgr := _get_output_manager():
                 with output_mgr.show_status_spinner():
                     yield app
+            else:
+                yield app
+            # successful completion!
+            await _status_based_disconnect(client, running_app.app_id, exc_info=None)
         except KeyboardInterrupt as e:
-            exc_info = e
-            # mute cancellation errors on all function handles to prevent exception spam
-            for obj in app.registered_functions.values():
-                obj._set_mute_cancellation(True)
-
+            # this happens only if sigint comes in during the yield block above
             if detach:
-                output_mgr.print_if_visible(step_completed("Shutting down Modal client."))
-                output_mgr.print_if_visible(
-                    f"""The detached app keeps running. You can track its progress at: [magenta]{running_app.app_page_url}[/magenta]"""
-                )
-                if not shell:
+                if output_mgr := _get_output_manager():
+                    output_mgr.print(output_mgr.step_completed("Shutting down Modal client."))
+                    output_mgr.print(
+                        "The detached app keeps running. You can track its progress at: "
+                        f"[magenta]{running_app.app_page_url}[/magenta]"
+                        ""
+                    )
+                if logs_loop:
                     logs_loop.cancel()
+                await _status_based_disconnect(client, running_app.app_id, e)
             else:
-                output_mgr.print_if_visible(
-                    step_completed(
-                        f"App aborted. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+                if output_mgr := _get_output_manager():
+                    output_mgr.print(
+                        "Disconnecting from Modal - This will terminate your Modal app in a few seconds.\n"
                     )
-                )
-                output_mgr.print_if_visible(
-                    "Disconnecting from Modal - This will terminate your Modal app in a few seconds.\n"
-                )
+                await _status_based_disconnect(client, running_app.app_id, e)
+                if logs_loop:
+                    try:
+                        await asyncio.wait_for(logs_loop, timeout=logs_timeout)
+                    except asyncio.TimeoutError:
+                        logger.warning("Timed out waiting for final app logs.")
+
+                if output_mgr:
+                    output_mgr.print(
+                        output_mgr.step_completed(
+                            "App aborted. "
+                            f"[grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+                        )
+                    )
+            return
         except BaseException as e:
-            exc_info = e
-            raise e
-        finally:
-            if isinstance(exc_info, KeyboardInterrupt):
-                reason = api_pb2.APP_DISCONNECT_REASON_KEYBOARD_INTERRUPT
-            elif exc_info is not None:
-                reason = api_pb2.APP_DISCONNECT_REASON_LOCAL_EXCEPTION
-            else:
-                reason = api_pb2.APP_DISCONNECT_REASON_ENTRYPOINT_COMPLETED
-
-            if isinstance(exc_info, _CliUserExecutionError):
-                exc_str = repr(exc_info.__cause__)
-            elif exc_info:
-                exc_str = repr(exc_info)
-            else:
-                exc_str = ""
-
-            await _disconnect(client, running_app.app_id, reason, exc_str)
-            app._uncreate_all_objects()
-
-    output_mgr.print_if_visible(
-        step_completed(f"App completed. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]")
-    )
+            logger.info("Exception during app run")
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
+
+        # wait for logs gracefully, even though the task context would do the same
+        # this allows us to log a more specific warning in case the app doesn't
+        # provide all logs before exit
+        if logs_loop:
+            try:
+                await asyncio.wait_for(logs_loop, timeout=logs_timeout)
+            except asyncio.TimeoutError:
+                logger.warning("Timed out waiting for final app logs.")
+
+    if output_mgr := _get_output_manager():
+        output_mgr.print(
+            output_mgr.step_completed(
+                f"App completed. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+            )
+        )
 
 
 async def _serve_update(
@@ -325,19 +421,20 @@ async def _serve_update(
     # Used by child process to reinitialize a served app
     client = await _Client.from_env()
     try:
-        running_app: RunningApp = await _init_local_app_existing(client, existing_app_id)
+        running_app: RunningApp = await _init_local_app_existing(client, existing_app_id, environment_name)
 
         # Create objects
-        output_mgr = OutputManager(None, True)
         await _create_all_objects(
             client,
             running_app,
-            app._indexed_objects,
-            api_pb2.APP_STATE_UNSPECIFIED,
+            app._functions,
+            app._classes,
             environment_name,
-            output_mgr=output_mgr,
         )
 
+        # Publish the updated app
+        await _publish_app(client, running_app, api_pb2.APP_STATE_UNSPECIFIED, app._functions, app._classes)
+
         # Communicate to the parent process
         is_ready.set()
     except asyncio.exceptions.CancelledError:
@@ -350,17 +447,18 @@ class DeployResult:
     """Dataclass representing the result of deploying an app."""
 
     app_id: str
+    app_page_url: str
+    app_logs_url: str
+    warnings: list[str]
 
 
 async def _deploy_app(
     app: _App,
-    name: str = None,
-    namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
-    client=None,
-    stdout=None,
-    show_progress=True,
+    name: Optional[str] = None,
+    namespace: Any = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
+    client: Optional[_Client] = None,
     environment_name: Optional[str] = None,
-    public: bool = False,
+    tag: str = "",
 ) -> DeployResult:
     """Deploy an app and export its objects persistently.
 
@@ -384,29 +482,33 @@ async def _deploy_app(
       referred to and used by other apps.
     """
     if environment_name is None:
-        environment_name = config.get("environment")
+        environment_name = typing.cast(str, config.get("environment"))
 
-    if name is None:
-        name = app.name
-    if name is None:
+    name = name or app.name
+    if not name:
         raise InvalidError(
-            "You need to either supply an explicit deployment name to the deploy command, or have a name set on the app.\n"
+            "You need to either supply an explicit deployment name to the deploy command, "
+            "or have a name set on the app.\n"
             "\n"
             "Examples:\n"
             'app.deploy("some_name")\n\n'
             "or\n"
             'app = App("some-name")'
         )
+    else:
+        check_object_name(name, "App")
 
-    if not is_valid_app_name(name):
+    if tag and not is_valid_tag(tag):
         raise InvalidError(
-            f"Invalid app name {name}. App names may only contain alphanumeric characters, dashes, periods, and underscores, and must be less than 64 characters in length. "
+            f"Deployment tag {tag!r} is invalid."
+            "\n\nTags may only contain alphanumeric characters, dashes, periods, and underscores, "
+            "and must be 50 characters or less"
         )
 
     if client is None:
         client = await _Client.from_env()
 
-    output_mgr = OutputManager(stdout, show_progress)
+    t0 = time.time()
 
     running_app: RunningApp = await _init_local_app_from_name(
         client, name, namespace, environment_name=environment_name
@@ -414,53 +516,44 @@ async def _deploy_app(
 
     async with TaskContext(0) as tc:
         # Start heartbeats loop to keep the client alive
-        tc.infinite_loop(lambda: _heartbeat(client, running_app.app_id), sleep=HEARTBEAT_INTERVAL)
+        def heartbeat():
+            return _heartbeat(client, running_app.app_id)
 
-        # Don't change the app state - deploy state is set by AppDeploy
-        post_init_state = api_pb2.APP_STATE_UNSPECIFIED
+        tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL)
 
         try:
             # Create all members
             await _create_all_objects(
                 client,
                 running_app,
-                app._indexed_objects,
-                post_init_state,
+                app._functions,
+                app._classes,
                 environment_name=environment_name,
-                output_mgr=output_mgr,
             )
 
-            # Deploy app
-            # TODO(erikbern): not needed if the app already existed
-            deploy_req = api_pb2.AppDeployRequest(
-                app_id=running_app.app_id,
-                name=name,
-                namespace=namespace,
-                object_entity="ap",
-                visibility=(
-                    api_pb2.APP_DEPLOY_VISIBILITY_PUBLIC if public else api_pb2.APP_DEPLOY_VISIBILITY_WORKSPACE
-                ),
+            app_url, warnings = await _publish_app(
+                client, running_app, api_pb2.APP_STATE_DEPLOYED, app._functions, app._classes, name, tag
             )
-            try:
-                deploy_response = await retry_transient_errors(client.stub.AppDeploy, deploy_req)
-            except GRPCError as exc:
-                if exc.status == Status.INVALID_ARGUMENT:
-                    raise InvalidError(exc.message)
-                if exc.status == Status.FAILED_PRECONDITION:
-                    raise InvalidError(exc.message)
-                raise
-            url = deploy_response.url
         except Exception as e:
             # Note that AppClientDisconnect only stops the app if it's still initializing, and is a no-op otherwise.
             await _disconnect(client, running_app.app_id, reason=api_pb2.APP_DISCONNECT_REASON_DEPLOYMENT_EXCEPTION)
             raise e
 
-    output_mgr.print_if_visible(step_completed("App deployed! 🎉"))
-    output_mgr.print_if_visible(f"\nView Deployment: [magenta]{url}[/magenta]")
-    return DeployResult(app_id=running_app.app_id)
+    if output_mgr := _get_output_manager():
+        t = time.time() - t0
+        output_mgr.print(output_mgr.step_completed(f"App deployed in {t:.3f}s! 🎉"))
+        output_mgr.print(f"\nView Deployment: [magenta]{app_url}[/magenta]")
+    return DeployResult(
+        app_id=running_app.app_id,
+        app_page_url=running_app.app_page_url,
+        app_logs_url=running_app.app_logs_url,  # type: ignore
+        warnings=[warning.message for warning in warnings],
+    )
 
 
-async def _interactive_shell(_app: _App, cmd: List[str], environment_name: str = "", **kwargs):
+async def _interactive_shell(
+    _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
+) -> None:
     """Run an interactive shell (like `bash`) within the image for this app.
 
     This is useful for online debugging and interactive exploration of the
@@ -477,41 +570,70 @@ async def _interactive_shell(_app: _App, cmd: List[str], environment_name: str =
 
     You can now run this using
 
-    ```bash
+    ```
     modal shell script.py --cmd /bin/bash
     ```
 
-    **kwargs will be passed into spawn_sandbox().
+    When calling programmatically, `kwargs` are passed to `Sandbox.create()`.
     """
+
     client = await _Client.from_env()
-    async with _run_app(_app, client, environment_name=environment_name, shell=True):
-        console = Console()
-        loading_status = console.status("Starting container...")
-        loading_status.start()
-
-        sandbox_cmds = cmd if len(cmd) > 0 else ["/bin/bash"]
-        sb = await _app.spawn_sandbox(*sandbox_cmds, pty_info=get_pty_info(shell=True), **kwargs)
-        for _ in range(40):
-            await asyncio.sleep(0.5)
-            resp = await sb._client.stub.SandboxGetTaskId(api_pb2.SandboxGetTaskIdRequest(sandbox_id=sb._object_id))
-            if resp.task_id != "":
-                break
-            # else: sandbox hasn't been assigned a task yet
-        else:
-            loading_status.stop()
-            raise InteractiveTimeoutError("Timed out while waiting for sandbox to start")
+    async with _run_app(_app, client=client, environment_name=environment_name):
+        sandbox_cmds = cmds if len(cmds) > 0 else ["/bin/bash"]
+        sandbox_env = {
+            "MODAL_TOKEN_ID": config["token_id"],
+            "MODAL_TOKEN_SECRET": config["token_secret"],
+            "MODAL_ENVIRONMENT": _get_environment_name(),
+        }
+        secrets = kwargs.pop("secrets", []) + [_Secret.from_dict(sandbox_env)]
+        with enable_output():  # show any image build logs
+            sandbox = await _Sandbox.create(
+                "sleep",
+                "100000",
+                app=_app,
+                secrets=secrets,
+                **kwargs,
+            )
+
+        try:
+            if pty:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, pty_info=get_pty_info(shell=True) if pty else None
+                )
+                await container_process.attach()
+            else:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+                )
+                await container_process.wait()
+        except InteractiveTimeoutError:
+            # Check on status of Sandbox. It may have crashed, causing connection failure.
+            req = api_pb2.SandboxWaitRequest(sandbox_id=sandbox._object_id, timeout=0)
+            resp = await retry_transient_errors(sandbox._client.stub.SandboxWait, req)
+            if resp.result.exception:
+                raise RemoteError(resp.result.exception)
+            else:
+                raise
+
+
+def _run_stub(*args: Any, **kwargs: Any):
+    """mdmd:hidden
+    `run_stub` has been renamed to `run_app` and is deprecated. Please update your code.
+    """
+    deprecation_error(
+        (2024, 5, 1), "`run_stub` has been renamed to `run_app` and is deprecated. Please update your code."
+    )
 
-        loading_status.stop()
-        await connect_to_sandbox(sb)
+
+def _deploy_stub(*args: Any, **kwargs: Any):
+    """mdmd:hidden"""
+    message = "`deploy_stub` has been renamed to `deploy_app`. Please update your code."
+    deprecation_error((2024, 5, 1), message)
 
 
 run_app = synchronize_api(_run_app)
 serve_update = synchronize_api(_serve_update)
 deploy_app = synchronize_api(_deploy_app)
 interactive_shell = synchronize_api(_interactive_shell)
-
-# Soon-to-be-deprecated ones, add warning soon
-_run_stub = _run_app
-run_stub = run_app
-_deploy_stub = _deploy_app
-deploy_stub = deploy_app
+run_stub = synchronize_api(_run_stub)
+deploy_stub = synchronize_api(_deploy_stub)