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

modal/cli/container.py

@@ -1,28 +1,37 @@
 # Copyright Modal Labs 2022
-
-from typing import List, Union
+from typing import Optional, Union
 
 import typer
 from rich.text import Text
 
-from modal._container_exec import container_exec
+from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
-from modal.cli.utils import display_table, timestamp_to_local
+from modal._utils.grpc_utils import retry_transient_errors
+from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs, timestamp_to_local
 from modal.client import _Client
+from modal.config import config
+from modal.container_process import _ContainerProcess
+from modal.environments import ensure_env
+from modal.object import _get_environment_name
+from modal.stream_type import StreamType
 from modal_proto import api_pb2
 
-container_cli = typer.Typer(name="container", help="Manage running containers.", no_args_is_help=True)
+container_cli = typer.Typer(name="container", help="Manage and connect to running containers.", no_args_is_help=True)
 
 
 @container_cli.command("list")
 @synchronizer.create_blocking
-async def list(json: bool = False):
+async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
     """List all containers that are currently running."""
+    env = ensure_env(env)
     client = await _Client.from_env()
-    res: api_pb2.TaskListResponse = await client.stub.TaskList(api_pb2.TaskListRequest())
+    environment_name = _get_environment_name(env)
+    res: api_pb2.TaskListResponse = await client.stub.TaskList(
+        api_pb2.TaskListRequest(environment_name=environment_name)
+    )
 
     column_names = ["Container ID", "App ID", "App Name", "Start Time"]
-    rows: List[List[Union[Text, str]]] = []
+    rows: list[list[Union[Text, str]]] = []
     res.tasks.sort(key=lambda task: task.started_at, reverse=True)
     for task_stats in res.tasks:
         rows.append(
@@ -34,16 +43,55 @@ async def list(json: bool = False):
             ]
         )
 
-    display_table(column_names, rows, json=json, title="Active Containers")
+    display_table(column_names, rows, json=json, title=f"Active Containers in environment: {environment_name}")
+
+
+@container_cli.command("logs")
+def logs(container_id: str = typer.Argument(help="Container ID")):
+    """Show logs for a specific container, streaming while active."""
+    stream_app_logs(task_id=container_id)
 
 
 @container_cli.command("exec")
 @synchronizer.create_blocking
 async def exec(
-    container_id: str = typer.Argument(help="Container ID."),
-    command: List[str] = typer.Argument(help="A command to run inside the container."),
-    pty: bool = typer.Option(is_flag=True, default=True, help="Run the command using a PTY."),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
+    container_id: str = typer.Argument(help="Container ID"),
+    command: list[str] = typer.Argument(
+        help="A command to run inside the container.\n\n"
+        "To pass command-line flags or options, add `--` before the start of your commands. "
+        "For example: `modal container exec <id> -- /bin/bash -c 'echo hi'`"
+    ),
 ):
     """Execute a command in a container."""
+
+    if pty is None:
+        pty = is_tty()
+
+    client = await _Client.from_env()
+
+    req = api_pb2.ContainerExecRequest(
+        task_id=container_id,
+        command=command,
+        pty_info=get_pty_info(shell=True) if pty else None,
+        runtime_debug=config.get("function_runtime_debug"),
+    )
+    res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
+
+    if pty:
+        await _ContainerProcess(res.exec_id, client).attach()
+    else:
+        # TODO: redirect stderr to its own stream?
+        await _ContainerProcess(res.exec_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT).wait()
+
+
+@container_cli.command("stop")
+@synchronizer.create_blocking
+async def stop(container_id: str = typer.Argument(help="Container ID")):
+    """Stop a currently-running container and reassign its in-progress inputs.
+
+    This will send the container a SIGINT signal that Modal will handle.
+    """
     client = await _Client.from_env()
-    await container_exec(container_id, command, pty=pty, client=client)
+    request = api_pb2.ContainerStopRequest(task_id=container_id)
+    await retry_transient_errors(client.stub.ContainerStop, request)

modal/cli/dict.py

@@ -0,0 +1,128 @@
+# Copyright Modal Labs 2024
+from typing import Optional
+
+import typer
+from rich.console import Console
+from typer import Argument, Option, Typer
+
+from modal._resolver import Resolver
+from modal._utils.async_utils import synchronizer
+from modal._utils.grpc_utils import retry_transient_errors
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
+from modal.client import _Client
+from modal.dict import _Dict
+from modal.environments import ensure_env
+from modal_proto import api_pb2
+
+dict_cli = Typer(
+    name="dict",
+    no_args_is_help=True,
+    help="Manage `modal.Dict` objects and inspect their contents.",
+)
+
+
+@dict_cli.command(name="create", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def create(name: str, *, env: Optional[str] = ENV_OPTION):
+    """Create a named Dict object.
+
+    Note: This is a no-op when the Dict already exists.
+    """
+    d = _Dict.from_name(name, environment_name=env, create_if_missing=True)
+    client = await _Client.from_env()
+    resolver = Resolver(client=client)
+    await resolver.load(d)
+
+
+@dict_cli.command(name="list", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
+    """List all named Dicts."""
+    env = ensure_env(env)
+    client = await _Client.from_env()
+    request = api_pb2.DictListRequest(environment_name=env)
+    response = await retry_transient_errors(client.stub.DictList, request)
+
+    rows = [(d.name, timestamp_to_local(d.created_at, json)) for d in response.dicts]
+    display_table(["Name", "Created at"], rows, json)
+
+
+@dict_cli.command("clear", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def clear(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+    """Clear the contents of a named Dict by deleting all of its data."""
+    d = await _Dict.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the contents of modal.Dict '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await d.clear()
+
+
+@dict_cli.command(name="delete", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+    """Delete a named Dict and all of its data."""
+    # Lookup first to validate the name, even though delete is a staticmethod
+    await _Dict.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.Dict '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await _Dict.delete(name, environment_name=env)
+
+
+@dict_cli.command(name="get", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def get(name: str, key: str, *, env: Optional[str] = ENV_OPTION):
+    """Print the value for a specific key.
+
+    Note: When using the CLI, keys are always interpreted as having a string type.
+    """
+    d = await _Dict.lookup(name, environment_name=env)
+    console = Console()
+    val = await d.get(key)
+    console.print(val)
+
+
+def _display(input: str, use_repr: bool) -> str:
+    val = repr(input) if use_repr else str(input)
+    return val[:80] + "..." if len(val) > 80 else val
+
+
+@dict_cli.command(name="items", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def items(
+    name: str,
+    n: int = Argument(default=20, help="Limit the number of entries shown"),
+    *,
+    all: bool = Option(False, "-a", "--all", help="Ignore N and print all entries in the Dict (may be slow)"),
+    use_repr: bool = Option(False, "-r", "--repr", help="Display items using `repr()` to see more details"),
+    json: bool = False,
+    env: Optional[str] = ENV_OPTION,
+):
+    """Print the contents of a Dict.
+
+    Note: By default, this command truncates the contents. Use the `N` argument to control the
+    amount of data shown or the `--all` option to retrieve the entire Dict, which may be slow.
+    """
+    d = await _Dict.lookup(name, environment_name=env)
+
+    i, items = 0, []
+    async for key, val in d.items():
+        i += 1
+        if not json and not all and i > n:
+            items.append(("...", "..."))
+            break
+        else:
+            if json:
+                display_item = key, val
+            else:
+                display_item = _display(key, use_repr), _display(val, use_repr)  # type: ignore  # mypy/issue/12056
+            items.append(display_item)
+
+    display_table(["Key", "Value"], items, json)

modal/cli/entry_point.py

@@ -12,10 +12,12 @@ from . import run
 from .app import app_cli
 from .config import config_cli
 from .container import container_cli
+from .dict import dict_cli
 from .environment import environment_cli
 from .launch import launch_cli
 from .network_file_system import nfs_cli
 from .profile import profile_cli
+from .queues import queue_cli
 from .secret import secret_cli
 from .token import _new_token, token_cli
 from .volume import volume_cli
@@ -81,22 +83,33 @@ async def setup(profile: Optional[str] = None):
     await _new_token(profile=profile, next_url="/home")
 
 
-entrypoint_cli_typer.add_typer(app_cli)
-entrypoint_cli_typer.add_typer(config_cli)
-entrypoint_cli_typer.add_typer(container_cli)
-entrypoint_cli_typer.add_typer(environment_cli)
-entrypoint_cli_typer.add_typer(launch_cli)
-entrypoint_cli_typer.add_typer(nfs_cli)
-entrypoint_cli_typer.add_typer(profile_cli)
-entrypoint_cli_typer.add_typer(secret_cli)
-entrypoint_cli_typer.add_typer(token_cli)
-entrypoint_cli_typer.add_typer(volume_cli)
-
-entrypoint_cli_typer.command("deploy", help="Deploy a Modal stub as an application.", no_args_is_help=True)(run.deploy)
+# Commands
+entrypoint_cli_typer.command("deploy", help="Deploy a Modal application.", no_args_is_help=True)(run.deploy)
 entrypoint_cli_typer.command("serve", no_args_is_help=True)(run.serve)
-entrypoint_cli_typer.command("setup", help="Bootstrap Modal's configuration.")(setup)
 entrypoint_cli_typer.command("shell")(run.shell)
+entrypoint_cli_typer.add_typer(launch_cli)
+
+# Deployments
+entrypoint_cli_typer.add_typer(app_cli, rich_help_panel="Deployments")
+entrypoint_cli_typer.add_typer(container_cli, rich_help_panel="Deployments")
+
+# Storage
+entrypoint_cli_typer.add_typer(dict_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(nfs_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(secret_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(queue_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(volume_cli, rich_help_panel="Storage")
+
+# Configuration
+entrypoint_cli_typer.add_typer(config_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(environment_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(profile_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(token_cli, rich_help_panel="Configuration")
+
+# Hide setup from help as it's redundant with modal token new, but nicer for onboarding
+entrypoint_cli_typer.command("setup", help="Bootstrap Modal's configuration.", rich_help_panel="Onboarding")(setup)
 
+# Special handling for modal run, which is more complicated
 entrypoint_cli = typer.main.get_command(entrypoint_cli_typer)
 entrypoint_cli.add_command(run.run, name="run")  # type: ignore
 entrypoint_cli.list_commands(None)  # type: ignore

modal/cli/environment.py

@@ -1,13 +1,16 @@
 # Copyright Modal Labs 2023
-from typing import Optional
+from typing import Annotated, Optional, Union
 
 import typer
 from click import UsageError
-from typing_extensions import Annotated
+from grpclib import GRPCError, Status
+from rich.text import Text
 
 from modal import environments
+from modal._utils.name_utils import check_environment_name
 from modal.cli.utils import display_table
 from modal.config import config
+from modal.exception import InvalidError
 
 ENVIRONMENT_HELP_TEXT = """Create and interact with Environments
 
@@ -24,7 +27,7 @@ while still being able to deploy changes to a live environment.
 environment_cli = typer.Typer(name="environment", help=ENVIRONMENT_HELP_TEXT, no_args_is_help=True)
 
 
-class RenderableBool:
+class RenderableBool(Text):
     def __init__(self, value: bool):
         self.value = value
 
@@ -33,12 +36,21 @@ class RenderableBool:
 
 
 @environment_cli.command(name="list", help="List all environments in the current workspace")
-def list(json: Optional[bool] = False):
+def list_(json: Optional[bool] = False):
     envs = environments.list_environments()
+
+    # determine which environment is currently active, prioritizing the local default
+    # over the server default
+    active_env = config.get("environment")
+    for env in envs:
+        if env.default is True and active_env is None:
+            active_env = env.name
+
     table_data = []
     for item in envs:
-        is_active = item.name == config.get("environment")
-        row = [item.name, item.webhook_suffix, is_active if json else RenderableBool(is_active)]
+        is_active = item.name == active_env
+        is_active_display: Union[Text, str] = str(is_active) if json else RenderableBool(is_active)
+        row = [item.name, item.webhook_suffix, is_active_display]
         table_data.append(row)
     display_table(["name", "web suffix", "active"], table_data, json=json)
 
@@ -48,7 +60,14 @@ ENVIRONMENT_CREATE_HELP = """Create a new environment in the current workspace""
 
 @environment_cli.command(name="create", help=ENVIRONMENT_CREATE_HELP)
 def create(name: Annotated[str, typer.Argument(help="Name of the new environment. Must be unique. Case sensitive")]):
-    environments.create_environment(name)
+    check_environment_name(name)
+
+    try:
+        environments.create_environment(name)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT:
+            raise InvalidError(exc.message)
+        raise
     typer.echo(f"Environment created: {name}")
 
 
@@ -65,7 +84,10 @@ def delete(
 ):
     if not confirm:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the environment '{name}' and all its associated apps and secrets?",
+            (
+                f"Are you sure you want to irrevocably delete the environment '{name}' and"
+                " all its associated apps and secrets?"
+            ),
             default=False,
             abort=True,
         )
@@ -88,5 +110,14 @@ def update(
     if set_name is None and set_web_suffix is None:
         raise UsageError("You need to at least one new property (using --set-name or --set-web-suffix)")
 
-    environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
+    if set_name:
+        check_environment_name(set_name)
+
+    try:
+        environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT:
+            raise InvalidError(exc.message)
+        raise
+
     typer.echo("Environment updated")

modal/cli/import_refs.py

@@ -18,9 +18,8 @@ import click
 from rich.console import Console
 from rich.markdown import Markdown
 
-import modal
 from modal.app import App, LocalEntrypoint
-from modal.exception import _CliUserExecutionError, deprecation_warning
+from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 
 
@@ -34,7 +33,7 @@ def parse_import_ref(object_ref: str) -> ImportRef:
     if object_ref.find("::") > 1:
         file_or_module, object_path = object_ref.split("::", 1)
     elif object_ref.find(":") > 1:
-        raise modal.exception.InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
+        raise InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
     else:
         file_or_module, object_path = object_ref, None
 
@@ -52,8 +51,14 @@ def import_file_or_module(file_or_module: str):
         sys.path.insert(0, "")  # "" means the current working directory
 
     if file_or_module.endswith(".py"):
-        # when using a script path, that scripts directory should also be on the path as it is with `python some/script.py`
+        # when using a script path, that scripts directory should also be on the path as it is
+        # with `python some/script.py`
         full_path = Path(file_or_module).resolve()
+        if "." in full_path.name.removesuffix(".py"):
+            raise InvalidError(
+                f"Invalid Modal source filename: {full_path.name!r}."
+                "\n\nSource filename cannot contain additional period characters."
+            )
         sys.path.insert(0, str(full_path.parent))
 
         module_name = inspect.getmodulename(file_or_module)
@@ -74,7 +79,7 @@ def import_file_or_module(file_or_module: str):
     return module
 
 
-def get_by_object_path(obj: Any, obj_path: Optional[str]) -> Optional[Any]:
+def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
     # Try to evaluate a `.`-delimited object path in a Modal context
     # With the caveat that some object names can actually have `.` in their name (lifecycled methods' tags)
 
@@ -102,40 +107,10 @@ def get_by_object_path(obj: Any, obj_path: Optional[str]) -> Optional[Any]:
     return obj
 
 
-def get_by_object_path_try_possible_app_names(obj: Any, obj_path: Optional[str]) -> Optional[Any]:
-    """This just exists as a dumb workaround to support both "stub" and "app" """
-
-    if obj_path:
-        return get_by_object_path(obj, obj_path)
-    else:
-        app = get_by_object_path(obj, DEFAULT_APP_NAME)
-        stub = get_by_object_path(obj, "stub")
-        if isinstance(app, App):
-            return app
-        elif app is not None and isinstance(stub, App):
-            deprecation_warning(
-                (2024, 4, 20),
-                "The symbol `app` is present at the module level but it's not a Modal app."
-                " We will use `stub` instead, but this will not work in future Modal versions."
-                " Suggestion: change the name of `app` to something else.",
-            )
-            return stub
-        elif isinstance(stub, App):
-            # TODO(erikbern): enable this deprecation warning shortly
-            # deprecation_warning(
-            #    (2024, 4, 20),
-            #    "The symbol `app` is not present but `stub` is. This will not work in future"
-            #    " Modal versions. Suggestion: change the name of `stub` to `app`."
-            # )
-            return stub
-        else:
-            return None
-
-
 def _infer_function_or_help(
     app: App, module, accept_local_entrypoint: bool, accept_webhook: bool
 ) -> Union[Function, LocalEntrypoint]:
-    function_choices = set(app.registered_functions.keys())
+    function_choices = set(app.registered_functions)
     if not accept_webhook:
         function_choices -= set(app.registered_web_endpoints)
     if accept_local_entrypoint:
@@ -179,7 +154,7 @@ Registered functions and local entrypoints on the selected app are:
         # entrypoint is in entrypoint registry, for now
         return app.registered_entrypoints[function_name]
 
-    function = app.indexed_objects[function_name]  # functions are in blueprint
+    function = app.registered_functions[function_name]
     assert isinstance(function, Function)
     return function
 
@@ -192,7 +167,8 @@ def _show_no_auto_detectable_app(app_ref: ImportRef) -> None:
 
     if object_path is None:
         guidance_msg = (
-            f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). If your `modal.App` is named differently, "
+            f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). "
+            "If your `modal.App` is named differently, "
             "you must specify it in the app ref argument. "
             f"For example an App variable `app_2 = modal.App()` in `{import_path}` would "
             f"be specified as `{import_path}::app_2`."
@@ -205,7 +181,7 @@ def import_app(app_ref: str) -> App:
     import_ref = parse_import_ref(app_ref)
 
     module = import_file_or_module(import_ref.file_or_module)
-    app = get_by_object_path_try_possible_app_names(module, import_ref.object_path)
+    app = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
 
     if app is None:
         _show_no_auto_detectable_app(import_ref)
@@ -223,11 +199,13 @@ def _show_function_ref_help(app_ref: ImportRef, base_cmd: str) -> None:
     error_console = Console(stderr=True)
     if object_path:
         error_console.print(
-            f"[bold red]Could not find Modal function or local entrypoint '{object_path}' in '{import_path}'.[/bold red]"
+            f"[bold red]Could not find Modal function or local entrypoint"
+            f" '{object_path}' in '{import_path}'.[/bold red]"
         )
     else:
         error_console.print(
-            f"[bold red]No function was specified, and no [green]`app`[/green] variable could be found in '{import_path}'.[/bold red]"
+            f"[bold red]No function was specified, and no [green]`app`[/green] variable "
+            f"could be found in '{import_path}'.[/bold red]"
         )
     guidance_msg = f"""
 Usage:
@@ -235,7 +213,7 @@ Usage:
 
 Given the following example `app.py`:
 ```
-app = modal.App()  # Note: "app" was called "stub" up until April 2024
+app = modal.App()
 
 @app.function()
 def foo():
@@ -251,7 +229,7 @@ def import_function(
     import_ref = parse_import_ref(func_ref)
 
     module = import_file_or_module(import_ref.file_or_module)
-    app_or_function = get_by_object_path_try_possible_app_names(module, import_ref.object_path)
+    app_or_function = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
 
     if app_or_function is None:
         _show_function_ref_help(import_ref, base_cmd)
@@ -272,8 +250,3 @@ def import_function(
         return app_or_function
     else:
         raise click.UsageError(f"{app_or_function} is not a Modal entity (should be an App or Function)")
-
-
-# For backwards compatibility - delete soon
-# We use it in our internal intergration tests
-import_stub = import_app

modal/cli/launch.py

@@ -4,12 +4,13 @@ import inspect
 import json
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from typer import Typer
 
 from ..app import App
 from ..exception import _CliUserExecutionError
+from ..output import enable_output
 from ..runner import run_app
 from .import_refs import import_function
 
@@ -17,15 +18,15 @@ launch_cli = Typer(
     name="launch",
     no_args_is_help=True,
     help="""
-    [Preview] Open a serverless app instance on Modal.
+    Open a serverless app instance on Modal.
 
     This command is in preview and may change in the future.
     """,
 )
 
 
-def _launch_program(name: str, filename: str, args: Dict[str, Any]) -> None:
-    os.environ["MODAL_LAUNCH_LOCAL_ARGS"] = json.dumps(args)
+def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]) -> None:
+    os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
     entrypoint = import_function(program_path, "modal launch")
@@ -35,14 +36,15 @@ def _launch_program(name: str, filename: str, args: Dict[str, Any]) -> None:
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.
     func = entrypoint.info.raw_f
     isasync = inspect.iscoroutinefunction(func)
-    with run_app(app):
-        try:
-            if isasync:
-                asyncio.run(func())
-            else:
-                func()
-        except Exception as exc:
-            raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
+    with enable_output():
+        with run_app(app, detach=detach):
+            try:
+                if isasync:
+                    asyncio.run(func())
+                else:
+                    func()
+            except Exception as exc:
+                raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
 
 
 @launch_cli.command(name="jupyter", help="Start Jupyter Lab on Modal.")
@@ -53,6 +55,9 @@ def jupyter(
     timeout: int = 3600,
     image: str = "ubuntu:22.04",
     add_python: Optional[str] = "3.11",
+    mount: Optional[str] = None,  # Adds a local directory to the jupyter container
+    volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
@@ -61,8 +66,10 @@ def jupyter(
         "timeout": timeout,
         "image": image,
         "add_python": add_python,
+        "mount": mount,
+        "volume": volume,
     }
-    _launch_program("jupyter", "run_jupyter.py", args)
+    _launch_program("jupyter", "run_jupyter.py", detach, args)
 
 
 @launch_cli.command(name="vscode", help="Start Visual Studio Code on Modal.")
@@ -70,12 +77,19 @@ 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).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
         "memory": memory,
         "gpu": gpu,
+        "image": image,
         "timeout": timeout,
+        "mount": mount,
+        "volume": volume,
     }
-    _launch_program("vscode", "vscode.py", args)
+    _launch_program("vscode", "vscode.py", detach, args)