modal 0.68.50__py3-none-any.whl → 0.71.5__py3-none-any.whl

modal/_container_entrypoint.py

@@ -11,7 +11,6 @@ if telemetry_socket:
     instrument_imports(telemetry_socket)
 
 import asyncio
-import base64
 import concurrent.futures
 import inspect
 import queue
@@ -337,14 +336,17 @@ def call_function(
                     signal.signal(signal.SIGUSR1, usr1_handler)  # reset signal handler
 
 
-def get_active_app_fallback(function_def: api_pb2.Function) -> Optional[_App]:
+def get_active_app_fallback(function_def: api_pb2.Function) -> _App:
     # This branch is reached in the special case that the imported function/class is:
     # 1) not serialized, and
     # 2) isn't a FunctionHandle - i.e, not decorated at definition time
     # Look at all instantiated apps - if there is only one with the indicated name, use that one
     app_name: Optional[str] = function_def.app_name or None  # coalesce protobuf field to None
     matching_apps = _App._all_apps.get(app_name, [])
-    active_app = None
+    if len(matching_apps) == 1:
+        active_app: _App = matching_apps[0]
+        return active_app
+
     if len(matching_apps) > 1:
         if app_name is not None:
             warning_sub_message = f"app with the same name ('{app_name}')"
@@ -354,12 +356,10 @@ def get_active_app_fallback(function_def: api_pb2.Function) -> Optional[_App]:
             f"You have more than one {warning_sub_message}. "
             "It's recommended to name all your Apps uniquely when using multiple apps"
         )
-    elif len(matching_apps) == 1:
-        (active_app,) = matching_apps
-    # there could also technically be zero found apps, but that should probably never be an
-    # issue since that would mean user won't use is_inside or other function handles anyway
 
-    return active_app
+    # If we don't have an active app, create one on the fly
+    # The app object is used to carry the app layout etc
+    return _App()
 
 
 def call_lifecycle_functions(
@@ -403,7 +403,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
     # This is a bit weird but we need both the blocking and async versions of ContainerIOManager.
     # At some point, we should fix that by having built-in support for running "user code"
     container_io_manager = ContainerIOManager(container_args, client)
-    active_app: Optional[_App] = None
+    active_app: _App
     service: Service
     function_def = container_args.function_def
     is_auto_snapshot: bool = function_def.is_auto_snapshot
@@ -450,8 +450,9 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 )
 
             # If the cls/function decorator was applied in local scope, but the app is global, we can look it up
-            active_app = service.app
-            if active_app is None:
+            if service.app is not None:
+                active_app = service.app
+            else:
                 # if the app can't be inferred by the imported function, use name-based fallback
                 active_app = get_active_app_fallback(function_def)
 
@@ -464,13 +465,12 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 batch_wait_ms = function_def.batch_linger_ms or 0
 
         # Get ids and metadata for objects (primarily functions and classes) on the app
-        container_app: RunningApp = container_io_manager.get_app_objects()
+        container_app: RunningApp = container_io_manager.get_app_objects(container_args.app_layout)
 
         # Initialize objects on the app.
         # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-        if active_app is not None:
-            app: App = synchronizer._translate_out(active_app)
-            app._init_container(client, container_app)
+        app: App = synchronizer._translate_out(active_app)
+        app._init_container(client, container_app)
 
         # Hydrate all function dependencies.
         # TODO(erikbern): we an remove this once we
@@ -581,7 +581,15 @@ if __name__ == "__main__":
     logger.debug("Container: starting")
 
     container_args = api_pb2.ContainerArguments()
-    container_args.ParseFromString(base64.b64decode(sys.argv[1]))
+
+    container_arguments_path: Optional[str] = os.environ.get("MODAL_CONTAINER_ARGUMENTS_PATH")
+    if container_arguments_path is None:
+        # TODO(erikbern): this fallback is for old workers and we can remove it very soon (days)
+        import base64
+
+        container_args.ParseFromString(base64.b64decode(sys.argv[1]))
+    else:
+        container_args.ParseFromString(open(container_arguments_path, "rb").read())
 
     # Note that we're creating the client in a synchronous context, but it will be running in a separate thread.
     # This is good because if the function is long running then we the client can still send heartbeats

modal/_runtime/container_io_manager.py

@@ -21,7 +21,6 @@ from typing import (
 )
 
 from google.protobuf.empty_pb2 import Empty
-from google.protobuf.message import Message
 from grpclib import Status
 from synchronicity.async_wrap import asynccontextmanager
 
@@ -31,12 +30,12 @@ from modal._traceback import extract_traceback, print_exception
 from modal._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
 from modal._utils.blob_utils import MAX_OBJECT_SIZE_BYTES, blob_download, blob_upload
 from modal._utils.function_utils import _stream_function_call_data
-from modal._utils.grpc_utils import get_proto_oneof, retry_transient_errors
+from modal._utils.grpc_utils import retry_transient_errors
 from modal._utils.package_utils import parse_major_minor_version
 from modal.client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
 from modal.config import config, logger
 from modal.exception import ClientClosed, InputCancellation, InvalidError, SerializationError
-from modal.running_app import RunningApp
+from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
 if TYPE_CHECKING:
@@ -450,26 +449,15 @@ class _ContainerIOManager:
 
             await asyncio.sleep(DYNAMIC_CONCURRENCY_INTERVAL_SECS)
 
-    async def get_app_objects(self) -> RunningApp:
-        req = api_pb2.AppGetObjectsRequest(app_id=self.app_id, include_unindexed=True, only_class_function=True)
-        resp = await retry_transient_errors(self._client.stub.AppGetObjects, req)
-        logger.debug(f"AppGetObjects received {len(resp.items)} objects for app {self.app_id}")
-
-        tag_to_object_id = {}
-        object_handle_metadata = {}
-        for item in resp.items:
-            handle_metadata: Optional[Message] = get_proto_oneof(item.object, "handle_metadata_oneof")
-            object_handle_metadata[item.object.object_id] = handle_metadata
-            if item.tag:
-                tag_to_object_id[item.tag] = item.object.object_id
-
-        return RunningApp(
-            self.app_id,
-            environment_name=self._environment_name,
-            tag_to_object_id=tag_to_object_id,
-            object_handle_metadata=object_handle_metadata,
-            client=self._client,
-        )
+    async def get_app_objects(self, app_layout: api_pb2.AppLayout) -> RunningApp:
+        if len(app_layout.objects) == 0:
+            # TODO(erikbern): this should never happen! let's keep it in here for a short second
+            # until we've sanity checked that this is, in fact, dead code.
+            req = api_pb2.AppGetLayoutRequest(app_id=self.app_id)
+            resp = await retry_transient_errors(self._client.stub.AppGetLayout, req)
+            app_layout = resp.app_layout
+
+        return running_app_from_layout(self.app_id, app_layout)
 
     async def get_serialized_function(self) -> tuple[Optional[Any], Optional[Callable[..., Any]]]:
         # Fetch the serialized function definition

modal/_utils/docker_utils.py

@@ -0,0 +1,64 @@
+# Copyright Modal Labs 2024
+import re
+import shlex
+from typing import Sequence
+
+from ..exception import InvalidError
+
+
+def extract_copy_command_patterns(dockerfile_lines: Sequence[str]) -> list[str]:
+    """
+    Extract all COPY command sources from a Dockerfile.
+    Combines multiline COPY commands into a single line.
+    """
+    copy_source_patterns: set[str] = set()
+    current_command = ""
+    copy_pattern = re.compile(r"^\s*COPY\s+(.+)$", re.IGNORECASE)
+
+    # First pass: handle line continuations and collect full commands
+    for line in dockerfile_lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            # ignore comments and empty lines
+            continue
+
+        if current_command:
+            # Continue previous line
+            current_command += " " + line.rstrip("\\").strip()
+        else:
+            # Start new command
+            current_command = line.rstrip("\\").strip()
+
+        if not line.endswith("\\"):
+            # Command is complete
+
+            match = copy_pattern.match(current_command)
+            if match:
+                args = match.group(1)
+                parts = shlex.split(args)
+
+                # COPY --from=... commands reference external sources and do not need a context mount.
+                # https://docs.docker.com/reference/dockerfile/#copy---from
+                if parts[0].startswith("--from="):
+                    current_command = ""
+                    continue
+
+                if len(parts) >= 2:
+                    # Last part is destination, everything else is a mount source
+                    sources = parts[:-1]
+
+                    for source in sources:
+                        special_pattern = re.compile(r"^\s*--|\$\s*")
+                        if special_pattern.match(source):
+                            raise InvalidError(
+                                f"COPY command: {source} using special flags/arguments/variables are not supported"
+                            )
+
+                        if source == ".":
+                            copy_source_patterns.add("./**")
+                        else:
+                            copy_source_patterns.add(source)
+
+            current_command = ""
+
+    return list(copy_source_patterns)

modal/_utils/function_utils.py

@@ -17,7 +17,14 @@ from modal_proto import api_pb2
 from .._serialization import deserialize, deserialize_data_format, serialize
 from .._traceback import append_modal_tb
 from ..config import config, logger
-from ..exception import DeserializationError, ExecutionError, FunctionTimeoutError, InvalidError, RemoteError
+from ..exception import (
+    DeserializationError,
+    ExecutionError,
+    FunctionTimeoutError,
+    InternalFailure,
+    InvalidError,
+    RemoteError,
+)
 from ..mount import ROOT_DIR, _is_modal_path, _Mount
 from .blob_utils import MAX_OBJECT_SIZE_BYTES, blob_download, blob_upload
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
@@ -463,6 +470,8 @@ async def _process_result(result: api_pb2.GenericResult, data_format: int, stub,
 
     if result.status == api_pb2.GenericResult.GENERIC_STATUS_TIMEOUT:
         raise FunctionTimeoutError(result.exception)
+    elif result.status == api_pb2.GenericResult.GENERIC_STATUS_INTERNAL_FAILURE:
+        raise InternalFailure(result.exception)
     elif result.status != api_pb2.GenericResult.GENERIC_STATUS_SUCCESS:
         if data:
             try:

modal/app.py

@@ -168,7 +168,7 @@ class _App:
     """
 
     _all_apps: ClassVar[dict[Optional[str], list["_App"]]] = {}
-    _container_app: ClassVar[Optional[RunningApp]] = None
+    _container_app: ClassVar[Optional["_App"]] = None
 
     _name: Optional[str]
     _description: Optional[str]
@@ -294,12 +294,7 @@ class _App:
         app = _App(name)
         app._app_id = response.app_id
         app._client = client
-        app._running_app = RunningApp(
-            response.app_id,
-            client=client,
-            environment_name=environment_name,
-            interactive=False,
-        )
+        app._running_app = RunningApp(response.app_id, interactive=False)
         return app
 
     def set_description(self, description: str):
@@ -463,8 +458,8 @@ class _App:
         if self._running_app:
             # If this is inside a container, then objects can be defined after app initialization.
             # So we may have to initialize objects once they get bound to the app.
-            if function.tag in self._running_app.tag_to_object_id:
-                object_id: str = self._running_app.tag_to_object_id[function.tag]
+            if function.tag in self._running_app.function_ids:
+                object_id: str = self._running_app.function_ids[function.tag]
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 function._hydrate(object_id, self._client, metadata)
 
@@ -476,8 +471,8 @@ class _App:
         if self._running_app:
             # If this is inside a container, then objects can be defined after app initialization.
             # So we may have to initialize objects once they get bound to the app.
-            if tag in self._running_app.tag_to_object_id:
-                object_id: str = self._running_app.tag_to_object_id[tag]
+            if tag in self._running_app.class_ids:
+                object_id: str = self._running_app.class_ids[tag]
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 cls._hydrate(object_id, self._client, metadata)
 
@@ -488,21 +483,21 @@ class _App:
         self._running_app = running_app
         self._client = client
 
-        _App._container_app = running_app
-
-        # Hydrate objects on app -- hydrating functions first so that when a class is being hydrated its
-        # corresponding class service function is already hydrated.
-        def hydrate_objects(objects_dict):
-            for tag, object_id in running_app.tag_to_object_id.items():
-                if tag in objects_dict:
-                    obj = objects_dict[tag]
-                    handle_metadata = running_app.object_handle_metadata[object_id]
-                    obj._hydrate(object_id, client, handle_metadata)
+        _App._container_app = self
 
         # Hydrate function objects
-        hydrate_objects(self._functions)
+        for tag, object_id in running_app.function_ids.items():
+            if tag in self._functions:
+                obj = self._functions[tag]
+                handle_metadata = running_app.object_handle_metadata[object_id]
+                obj._hydrate(object_id, client, handle_metadata)
+
         # Hydrate class objects
-        hydrate_objects(self._classes)
+        for tag, object_id in running_app.class_ids.items():
+            if tag in self._classes:
+                obj = self._classes[tag]
+                handle_metadata = running_app.object_handle_metadata[object_id]
+                obj._hydrate(object_id, client, handle_metadata)
 
     @property
     def registered_functions(self) -> dict[str, _Function]:
@@ -1047,6 +1042,13 @@ class _App:
                     if log.data:
                         yield log.data
 
+    @classmethod
+    def _get_container_app(cls) -> Optional["_App"]:
+        """Returns the `App` running inside a container.
+
+        This will return `None` outside of a Modal container."""
+        return cls._container_app
+
     @classmethod
     def _reset_container_app(cls):
         """Only used for tests."""

modal/app.pyi

@@ -73,7 +73,7 @@ class _FunctionDecoratorType:
 
 class _App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[_App]]]
-    _container_app: typing.ClassVar[typing.Optional[modal.running_app.RunningApp]]
+    _container_app: typing.ClassVar[typing.Optional[_App]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
     _functions: dict[str, modal.functions._Function]
@@ -266,11 +266,13 @@ class _App:
         self, client: typing.Optional[modal.client._Client] = None
     ) -> collections.abc.AsyncGenerator[str, None]: ...
     @classmethod
+    def _get_container_app(cls) -> typing.Optional[_App]: ...
+    @classmethod
     def _reset_container_app(cls): ...
 
 class App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[App]]]
-    _container_app: typing.ClassVar[typing.Optional[modal.running_app.RunningApp]]
+    _container_app: typing.ClassVar[typing.Optional[App]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
     _functions: dict[str, modal.functions.Function]
@@ -530,6 +532,8 @@ class App:
 
     _logs: ___logs_spec
 
+    @classmethod
+    def _get_container_app(cls) -> typing.Optional[App]: ...
     @classmethod
     def _reset_container_app(cls): ...
 

modal/cli/launch.py

@@ -77,6 +77,7 @@ def vscode(
     cpu: int = 8,
     memory: int = 32768,
     gpu: Optional[str] = None,
+    image: str = "debian:12",
     timeout: int = 3600,
     mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
     volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
@@ -86,6 +87,7 @@ def vscode(
         "cpu": cpu,
         "memory": memory,
         "gpu": gpu,
+        "image": image,
         "timeout": timeout,
         "mount": mount,
         "volume": volume,

modal/cli/programs/vscode.py

@@ -15,9 +15,34 @@ from modal import App, Image, Mount, Queue, Secret, Volume, forward
 # Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
 args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
 
+CODE_SERVER_INSTALLER = "https://code-server.dev/install.sh"
+CODE_SERVER_ENTRYPOINT = (
+    "https://raw.githubusercontent.com/coder/code-server/refs/tags/v4.96.1/ci/release-image/entrypoint.sh"
+)
+FIXUD_INSTALLER = "https://github.com/boxboat/fixuid/releases/download/v0.6.0/fixuid-0.6.0-linux-$ARCH.tar.gz"
+
 
 app = App()
-app.image = Image.from_registry("codercom/code-server", add_python="3.11").dockerfile_commands("ENTRYPOINT []")
+app.image = (
+    Image.from_registry(args.get("image"), add_python="3.11")
+    .apt_install("curl", "dumb-init", "git", "git-lfs")
+    .run_commands(
+        f"curl -fsSL {CODE_SERVER_INSTALLER} | sh",
+        f"curl -fsSL {CODE_SERVER_ENTRYPOINT}  > /code-server.sh",
+        "chmod u+x /code-server.sh",
+    )
+    .run_commands(
+        'ARCH="$(dpkg --print-architecture)"'
+        f' && curl -fsSL "{FIXUD_INSTALLER}" | tar -C /usr/local/bin -xzf - '
+        " && chown root:root /usr/local/bin/fixuid"
+        " && chmod 4755 /usr/local/bin/fixuid"
+        " && mkdir -p /etc/fixuid"
+        ' && echo "user: root" >> /etc/fixuid/config.yml'
+        ' && echo "group: root" >> /etc/fixuid/config.yml'
+    )
+    .run_commands("mkdir /home/coder")
+    .env({"ENTRYPOINTD": ""})
+)
 
 
 mount = (
@@ -71,7 +96,7 @@ def run_vscode(q: Queue):
         url = tunnel.url
         threading.Thread(target=wait_for_port, args=((url, token), q)).start()
         subprocess.run(
-            ["/usr/bin/entrypoint.sh", "--bind-addr", "0.0.0.0:8080", "."],
+            ["/code-server.sh", "--bind-addr", "0.0.0.0:8080", "."],
             env={**os.environ, "SHELL": "/bin/bash", "PASSWORD": token},
         )
     q.put("done")

modal/cli/run.py

@@ -461,7 +461,7 @@ def shell(
         ):
             from .container import exec
 
-            exec(container_id=container_or_function, command=shlex.split(cmd))
+            exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
             return
 
         function = import_function(

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.50"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.5"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.50"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.5"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/exception.py

@@ -108,6 +108,12 @@ class ServerWarning(UserWarning):
     """Warning originating from the Modal server and re-issued in client code."""
 
 
+class InternalFailure(Error):
+    """
+    Retriable internal error.
+    """
+
+
 class _CliUserExecutionError(Exception):
     """mdmd:hidden
     Private wrapper for exceptions during when importing or running stubs from the CLI.

modal/experimental.py

@@ -48,6 +48,9 @@ def clustered(size: int, broadcast: bool = True):
 
     assert broadcast, "broadcast=False has not been implemented yet!"
 
+    if size <= 0:
+        raise ValueError("cluster size must be greater than 0")
+
     def wrapper(raw_f: Callable[..., Any]) -> _PartialFunction:
         if isinstance(raw_f, _Function):
             raw_f = raw_f.get_raw_f()

modal/file_io.py

@@ -1,6 +1,8 @@
 # Copyright Modal Labs 2024
 import asyncio
+import enum
 import io
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, AsyncIterator, Generic, Optional, Sequence, TypeVar, Union, cast
 
 if TYPE_CHECKING:
@@ -11,6 +13,7 @@ import json
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal._utils.grpc_utils import retry_transient_errors
+from modal.io_streams_helper import consume_stream_with_retries
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -18,7 +21,8 @@ from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 from .client import _Client
 from .exception import FilesystemExecutionError, InvalidError
 
-LARGE_FILE_SIZE_LIMIT = 16 * 1024 * 1024  # 16 MiB
+WRITE_CHUNK_SIZE = 16 * 1024 * 1024  # 16 MiB
+WRITE_FILE_SIZE_LIMIT = 1024 * 1024 * 1024  # 1 GiB
 READ_FILE_SIZE_LIMIT = 100 * 1024 * 1024  # 100 MiB
 
 ERROR_MAPPING = {
@@ -77,7 +81,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
     if start is not None and end is not None:
         if start >= end:
             raise InvalidError("start must be less than end")
-    if len(data) > LARGE_FILE_SIZE_LIMIT:
+    if len(data) > WRITE_CHUNK_SIZE:
         raise InvalidError("Write request payload exceeds 16 MiB limit")
     resp = await file._make_request(
         api_pb2.ContainerFilesystemExecRequest(
@@ -93,6 +97,20 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
     await file._wait(resp.exec_id)
 
 
+class FileWatchEventType(enum.Enum):
+    Unknown = "Unknown"
+    Access = "Access"
+    Create = "Create"
+    Modify = "Modify"
+    Remove = "Remove"
+
+
+@dataclass
+class FileWatchEvent:
+    paths: list[str]
+    type: FileWatchEventType
+
+
 # The FileIO class is designed to mimic Python's io.FileIO
 # See https://github.com/python/cpython/blob/main/Lib/_pyio.py#L1459
 class _FileIO(Generic[T]):
@@ -123,6 +141,7 @@ class _FileIO(Generic[T]):
     _task_id: str = ""
     _file_descriptor: str = ""
     _client: Optional[_Client] = None
+    _watch_output_buffer: list[Optional[bytes]] = []
 
     def _validate_mode(self, mode: str) -> None:
         if not any(char in mode for char in "rwax"):
@@ -166,6 +185,44 @@ class _FileIO(Generic[T]):
             for message in batch.output:
                 yield message
 
+    async def _consume_watch_output(self, exec_id: str) -> None:
+        def item_handler(item: Optional[bytes]):
+            self._watch_output_buffer.append(item)
+
+        def completion_check(item: Optional[bytes]):
+            return item is None
+
+        await consume_stream_with_retries(
+            self._consume_output(exec_id),
+            item_handler,
+            completion_check,
+        )
+
+    async def _parse_watch_output(self, event: bytes) -> Optional[FileWatchEvent]:
+        try:
+            event_json = json.loads(event.decode())
+            return FileWatchEvent(type=FileWatchEventType(event_json["event_type"]), paths=event_json["paths"])
+        except (json.JSONDecodeError, KeyError, ValueError):
+            # skip invalid events
+            return None
+
+    async def _stream_watch_output(self) -> AsyncIterator[FileWatchEvent]:
+        buffer = b""
+        while True:
+            if len(self._watch_output_buffer) > 0:
+                item = self._watch_output_buffer.pop(0)
+                if item is None:
+                    break
+                buffer += item
+                # a single event may be split across multiple messages, the end of an event is marked by two newlines
+                if buffer.endswith(b"\n\n"):
+                    event = await self._parse_watch_output(buffer.strip())
+                    if event is not None:
+                        yield event
+                    buffer = b""
+            else:
+                await asyncio.sleep(0.1)
+
     async def _wait(self, exec_id: str) -> bytes:
         # The logic here is similar to how output is read from `exec`
         output = b""
@@ -288,15 +345,20 @@ class _FileIO(Generic[T]):
         self._validate_type(data)
         if isinstance(data, str):
             data = data.encode("utf-8")
-        if len(data) > LARGE_FILE_SIZE_LIMIT:
-            raise ValueError("Write request payload exceeds 16 MiB limit")
-        resp = await self._make_request(
-            api_pb2.ContainerFilesystemExecRequest(
-                file_write_request=api_pb2.ContainerFileWriteRequest(file_descriptor=self._file_descriptor, data=data),
-                task_id=self._task_id,
+        if len(data) > WRITE_FILE_SIZE_LIMIT:
+            raise ValueError("Write request payload exceeds 1 GiB limit")
+        for i in range(0, len(data), WRITE_CHUNK_SIZE):
+            chunk = data[i : i + WRITE_CHUNK_SIZE]
+            resp = await self._make_request(
+                api_pb2.ContainerFilesystemExecRequest(
+                    file_write_request=api_pb2.ContainerFileWriteRequest(
+                        file_descriptor=self._file_descriptor,
+                        data=chunk,
+                    ),
+                    task_id=self._task_id,
+                )
             )
-        )
-        await self._wait(resp.exec_id)
+            await self._wait(resp.exec_id)
 
     async def flush(self) -> None:
         """Flush the buffer to disk."""
@@ -385,6 +447,36 @@ class _FileIO(Generic[T]):
         )
         await self._wait(resp.exec_id)
 
+    @classmethod
+    async def watch(
+        cls,
+        path: str,
+        client: _Client,
+        task_id: str,
+        filter: Optional[list[FileWatchEventType]] = None,
+        recursive: bool = False,
+        timeout: Optional[int] = None,
+    ) -> AsyncIterator[FileWatchEvent]:
+        self = cls.__new__(cls)
+        self._client = client
+        self._task_id = task_id
+        resp = await self._make_request(
+            api_pb2.ContainerFilesystemExecRequest(
+                file_watch_request=api_pb2.ContainerFileWatchRequest(
+                    path=path,
+                    recursive=recursive,
+                    timeout_secs=timeout,
+                ),
+                task_id=self._task_id,
+            )
+        )
+        task = asyncio.create_task(self._consume_watch_output(resp.exec_id))
+        async for event in self._stream_watch_output():
+            if filter and event.type not in filter:
+                continue
+            yield event
+        task.cancel()
+
     async def _close(self) -> None:
         # Buffer is flushed by the runner on close
         resp = await self._make_request(