pymobiledevice3 6.2.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

pymobiledevice3/cli/remote.py

@@ -4,14 +4,15 @@ import logging
 import sys
 import tempfile
 from functools import partial
-from typing import Optional, TextIO
+from pathlib import Path
+from typing import Annotated, Optional, TextIO
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
 from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remotepairing_manual_pairing
 from pymobiledevice3.cli.cli_common import (
-    BaseCommand,
-    RSDCommand,
+    RSDServiceProviderDep,
     print_json,
     prompt_device_list,
     sudo_required,
@@ -38,6 +39,7 @@ logger = logging.getLogger(__name__)
 async def browse_rsd(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[dict]:
     devices = []
     for rsd in await get_rsds(timeout):
+        assert rsd.peer_info is not None
         devices.append({
             "address": rsd.service.address[0],
             "port": RSD_PORT,
@@ -66,40 +68,36 @@ async def cli_browse(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> None:
     })
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group("remote")
-def remote_cli() -> None:
-    """Create RemoteXPC tunnels"""
-    pass
+cli = InjectingTyper(
+    name="remote",
+    help="Create and browse RemoteXPC tunnels (RSD/tunneld) for developer services.",
+    no_args_is_help=True,
+)
 
 
-@remote_cli.command("tunneld", cls=BaseCommand)
-@click.option("--host", default=TUNNELD_DEFAULT_ADDRESS[0])
-@click.option("--port", type=click.INT, default=TUNNELD_DEFAULT_ADDRESS[1])
-@click.option("-d", "--daemonize", is_flag=True)
-@click.option(
-    "-p",
-    "--protocol",
-    type=click.Choice([e.value for e in TunnelProtocol]),
-    help="Transport protocol. If python version >= 3.13 will default to TCP. Otherwise will default to QUIC",
-    default=TunnelProtocol.DEFAULT.value,
-)
-@click.option("--usb/--no-usb", default=True, help="Enable usb monitoring")
-@click.option("--wifi/--no-wifi", default=True, help="Enable wifi monitoring")
-@click.option("--usbmux/--no-usbmux", default=True, help="Enable usbmux monitoring")
-@click.option("--mobdev2/--no-mobdev2", default=True, help="Enable mobdev2 monitoring")
+@cli.command("tunneld")
 @sudo_required
 def cli_tunneld(
-    host: str, port: int, daemonize: bool, protocol: str, usb: bool, wifi: bool, usbmux: bool, mobdev2: bool
+    host: Annotated[str, typer.Option(help="Address to bind the tunneld server to.")] = TUNNELD_DEFAULT_ADDRESS[0],
+    port: Annotated[int, typer.Option(help="Port to bind the tunneld server to.")] = TUNNELD_DEFAULT_ADDRESS[1],
+    daemonize: Annotated[bool, typer.Option("--daemonize", "-d", help="Run tunneld in the background.")] = False,
+    protocol: Annotated[
+        TunnelProtocol,
+        typer.Option(
+            "--protocol",
+            "-p",
+            case_sensitive=False,
+            help="Transport protocol for tunneld (default: TCP on Python >=3.13, otherwise QUIC).",
+        ),
+    ] = TunnelProtocol.DEFAULT,
+    usb: Annotated[bool, typer.Option(help="Enable USB monitoring")] = True,
+    wifi: Annotated[bool, typer.Option(help="Enable WiFi monitoring")] = True,
+    usbmux: Annotated[bool, typer.Option(help="Enable usbmux monitoring")] = True,
+    mobdev2: Annotated[bool, typer.Option(help="Enable mobdev2 monitoring")] = True,
 ) -> None:
     """Start Tunneld service for remote tunneling"""
     if not verify_tunnel_imports():
         return
-    protocol = TunnelProtocol(protocol)
     tunneld_runner = partial(
         TunneldRunner.create,
         host,
@@ -123,15 +121,16 @@ def cli_tunneld(
         tunneld_runner()
 
 
-@remote_cli.command("browse", cls=BaseCommand)
-@click.option("--timeout", type=click.FLOAT, default=DEFAULT_BONJOUR_TIMEOUT, help="Bonjour timeout (in seconds)")
-def browse(timeout: float) -> None:
+@cli.command("browse")
+def browse(
+    timeout: Annotated[float, typer.Option(help="Bonjour timeout (in seconds)")] = DEFAULT_BONJOUR_TIMEOUT,
+) -> None:
     """browse RemoteXPC devices using bonjour"""
     asyncio.run(cli_browse(timeout), debug=True)
 
 
-@remote_cli.command("rsd-info", cls=RSDCommand)
-def rsd_info(service_provider: RemoteServiceDiscoveryService):
+@cli.command("rsd-info")
+def rsd_info(service_provider: RSDServiceProviderDep) -> None:
     """show info extracted from RSD peer"""
     print_json(service_provider.peer_info)
 
@@ -153,32 +152,32 @@ async def tunnel_task(
             if user_requested_colored_output():
                 if secrets is not None:
                     print(
-                        click.style("Secrets: ", bold=True, fg="magenta")
-                        + click.style(secrets.name, bold=True, fg="white")
+                        typer.style("Secrets: ", bold=True, fg="magenta")
+                        + typer.style(secrets.name, bold=True, fg="white")
                     )
                 print(
-                    click.style("Identifier: ", bold=True, fg="yellow")
-                    + click.style(service.remote_identifier, bold=True, fg="white")
+                    typer.style("Identifier: ", bold=True, fg="yellow")
+                    + typer.style(service.remote_identifier, bold=True, fg="white")
                 )
                 print(
-                    click.style("Interface: ", bold=True, fg="yellow")
-                    + click.style(tunnel_result.interface, bold=True, fg="white")
+                    typer.style("Interface: ", bold=True, fg="yellow")
+                    + typer.style(tunnel_result.interface, bold=True, fg="white")
                 )
                 print(
-                    click.style("Protocol: ", bold=True, fg="yellow")
-                    + click.style(tunnel_result.protocol, bold=True, fg="white")
+                    typer.style("Protocol: ", bold=True, fg="yellow")
+                    + typer.style(tunnel_result.protocol, bold=True, fg="white")
                 )
                 print(
-                    click.style("RSD Address: ", bold=True, fg="yellow")
-                    + click.style(tunnel_result.address, bold=True, fg="white")
+                    typer.style("RSD Address: ", bold=True, fg="yellow")
+                    + typer.style(tunnel_result.address, bold=True, fg="white")
                 )
                 print(
-                    click.style("RSD Port: ", bold=True, fg="yellow")
-                    + click.style(tunnel_result.port, bold=True, fg="white")
+                    typer.style("RSD Port: ", bold=True, fg="yellow")
+                    + typer.style(tunnel_result.port, bold=True, fg="white")
                 )
                 print(
-                    click.style("Use the follow connection option:\n", bold=True, fg="yellow")
-                    + click.style(f"--rsd {tunnel_result.address} {tunnel_result.port}", bold=True, fg="cyan")
+                    typer.style("Use the follow connection option:\n", bold=True, fg="yellow")
+                    + typer.style(f"--rsd {tunnel_result.address} {tunnel_result.port}", bold=True, fg="cyan")
                 )
             else:
                 if secrets is not None:
@@ -224,52 +223,60 @@ async def start_tunnel_task(
     )
 
 
-@remote_cli.command("start-tunnel", cls=BaseCommand)
-@click.option(
-    "-t",
-    "--connection-type",
-    type=click.Choice([e.value for e in ConnectionType], case_sensitive=False),
-    default=ConnectionType.USB.value,
-)
-@click.option("--udid", help="UDID for a specific device to look for")
-@click.option("--secrets", type=click.File("wt"), help="TLS keyfile for decrypting with Wireshark")
-@click.option(
-    "--script-mode",
-    is_flag=True,
-    help="Show only HOST and port number to allow easy parsing from external shell scripts",
-)
-@click.option(
-    "--max-idle-timeout", type=click.FLOAT, default=MAX_IDLE_TIMEOUT, help="Maximum QUIC idle time (ping interval)"
-)
-@click.option(
-    "-p",
-    "--protocol",
-    type=click.Choice([e.value for e in TunnelProtocol], case_sensitive=False),
-    default=TunnelProtocol.DEFAULT.value,
-)
+@cli.command("start-tunnel")
 @sudo_required
 def cli_start_tunnel(
-    connection_type: ConnectionType,
-    udid: Optional[str],
-    secrets: TextIO,
-    script_mode: bool,
-    max_idle_timeout: float,
-    protocol: str,
+    *,
+    connection_type: Annotated[
+        ConnectionType,
+        typer.Option(
+            "--connection-type",
+            "-t",
+            case_sensitive=False,
+            help="Connection interface to tunnel (USB, WiFi, etc.).",
+        ),
+    ] = ConnectionType.USB,
+    udid: Annotated[
+        Optional[str],
+        typer.Option(help="UDID for a specific device to look for"),
+    ] = None,
+    secrets: Annotated[
+        Path,
+        typer.Option(help="File to write TLS secrets for Wireshark decryption."),
+    ],
+    script_mode: Annotated[
+        bool,
+        typer.Option(help="Print only HOST and port for scripts instead of formatted output."),
+    ] = False,
+    max_idle_timeout: Annotated[
+        float,
+        typer.Option(help="Maximum idle time before QUIC keepalive pings are sent."),
+    ] = MAX_IDLE_TIMEOUT,
+    protocol: Annotated[
+        TunnelProtocol,
+        typer.Option(
+            "--protocol",
+            "-p",
+            case_sensitive=False,
+            help="Transport protocol for the tunnel (default: TCP on Python >=3.13, otherwise QUIC).",
+        ),
+    ] = TunnelProtocol.DEFAULT,
 ) -> None:
     """start tunnel"""
     if not verify_tunnel_imports():
         return
-    asyncio.run(
-        start_tunnel_task(
-            ConnectionType(connection_type),
-            secrets,
-            udid,
-            script_mode,
-            max_idle_timeout=max_idle_timeout,
-            protocol=TunnelProtocol(protocol),
-        ),
-        debug=True,
-    )
+    with secrets.open("wt") as secrets_file:
+        asyncio.run(
+            start_tunnel_task(
+                connection_type,
+                secrets_file,
+                udid,
+                script_mode,
+                max_idle_timeout=max_idle_timeout,
+                protocol=protocol,
+            ),
+            debug=True,
+        )
 
 
 @dataclasses.dataclass
@@ -280,7 +287,7 @@ class RemotePairingManualPairingDevice:
     identifier: str
 
 
-async def start_remote_pair_task(device_name: str) -> None:
+async def start_remote_pair_task(device_name: Optional[str]) -> None:
     if start_tunnel is None:
         raise NotImplementedError("failed to start the tunnel on your platform")
 
@@ -311,17 +318,20 @@ async def start_remote_pair_task(device_name: str) -> None:
         await service.connect(autopair=True)
 
 
-@remote_cli.command("pair", cls=BaseCommand)
-@click.option("--name", help="Device name for a specific device to look for")
-def cli_pair(name: Optional[str]) -> None:
+@cli.command("pair")
+def cli_pair(
+    name: Annotated[
+        Optional[str],
+        typer.Option(help="Device name for a specific device to look for"),
+    ] = None,
+) -> None:
     """start remote pairing for devices which allow"""
     asyncio.run(start_remote_pair_task(name), debug=True)
 
 
-@remote_cli.command("delete-pair", cls=BaseCommand)
-@click.argument("udid")
+@cli.command("delete-pair")
 @sudo_required
-def cli_delete_pair(udid: str):
+def cli_delete_pair(udid: str) -> None:
     """delete a pairing record"""
     pair_record_path = get_home_folder() / f"{get_remote_pairing_record_filename(udid)}.{PAIRING_RECORD_EXT}"
     pair_record_path.unlink()
@@ -332,8 +342,7 @@ async def cli_service_task(service_provider: RemoteServiceDiscoveryService, serv
         service.shell()
 
 
-@remote_cli.command("service", cls=RSDCommand)
-@click.argument("service_name")
-def cli_service(service_provider: RemoteServiceDiscoveryService, service_name: str) -> None:
+@cli.command("service")
+def cli_service(service_provider: RSDServiceProviderDep, service_name: str) -> None:
     """start an ipython shell for interacting with given service"""
     asyncio.run(cli_service_task(service_provider, service_name), debug=True)

pymobiledevice3/cli/restore.py

@@ -4,18 +4,20 @@ import logging
 import plistlib
 import tempfile
 import traceback
-from collections.abc import Generator
+from collections.abc import Iterator
 from pathlib import Path
-from typing import IO, Optional, Union
+from typing import IO, Annotated, Optional
 from zipfile import ZipFile
 
 import click
 import IPython
 import requests
+import typer
 from pygments import formatters, highlight, lexers
+from typer_injector import Depends, InjectingTyper
 
 from pymobiledevice3 import usbmux
-from pymobiledevice3.cli.cli_common import is_invoked_for_completion, print_json, prompt_selection, set_verbosity
+from pymobiledevice3.cli.cli_common import is_invoked_for_completion, print_json, prompt_selection
 from pymobiledevice3.exceptions import ConnectionFailedError, ConnectionFailedToUsbmuxdError, IncorrectModeError
 from pymobiledevice3.irecv import IRecv
 from pymobiledevice3.lockdown import LockdownClient, create_using_usbmux
@@ -25,55 +27,66 @@ from pymobiledevice3.restore.restore import Restore
 from pymobiledevice3.services.diagnostics import DiagnosticsService
 from pymobiledevice3.utils import file_download
 
+logger = logging.getLogger(__name__)
+
+
 SHELL_USAGE = """
 # use `irecv` variable to access Restore mode API
 # for example:
 print(irecv.getenv('build-version'))
 """
-
-logger = logging.getLogger(__name__)
 IPSWME_API = "https://api.ipsw.me/v4/device/"
 
 
-class Command(click.Command):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.params[:0] = [
-            click.Option(("device", "--ecid"), type=click.INT, callback=self.device),
-            click.Option(("verbosity", "-v", "--verbose"), count=True, callback=set_verbosity, expose_value=False),
-        ]
-
-    @staticmethod
-    def device(ctx, param, value) -> Optional[Union[LockdownClient, IRecv]]:
-        if is_invoked_for_completion():
-            # prevent lockdown connection establishment when in autocomplete mode
-            return
-
-        ecid = value
-        logger.debug("searching among connected devices via lockdownd")
-        devices = [dev for dev in usbmux.list_devices() if dev.connection_type == "USB"]
-        if len(devices) > 1:
-            raise click.ClickException("Multiple device detected")
-        try:
-            for device in devices:
-                try:
-                    lockdown = create_using_usbmux(serial=device.serial, connection_type="USB")
-                except (ConnectionFailedError, IncorrectModeError):
-                    continue
-                if (ecid is None) or (lockdown.ecid == value):
-                    logger.debug("found device")
-                    return lockdown
-                else:
-                    continue
-        except ConnectionFailedToUsbmuxdError:
-            pass
-
-        logger.debug("waiting for device to be available in Recovery mode")
-        return IRecv(ecid=ecid)
+cli = InjectingTyper(
+    name="restore",
+    help="Restore/erase IPSWs, fetch blobs, and manage devices in Recovery/DFU.",
+    no_args_is_help=True,
+)
+
+
+def device_dependency(
+    ecid: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Target device ECID; defaults to the first connected USB device or waits for Recovery/DFU.",
+        ),
+    ] = None,
+) -> Optional[Device]:
+    if is_invoked_for_completion():
+        # prevent lockdown connection establishment when in autocomplete mode
+        return None
+
+    logger.debug("searching among connected devices via lockdownd")
+    devices = [dev for dev in usbmux.list_devices() if dev.connection_type == "USB"]
+    if len(devices) > 1:
+        raise click.ClickException("Multiple device detected")
+    try:
+        for device in devices:
+            try:
+                lockdown = create_using_usbmux(serial=device.serial, connection_type="USB")
+            except (ConnectionFailedError, IncorrectModeError):
+                continue
+            if (ecid is None) or (lockdown.ecid == ecid):
+                logger.debug("found device")
+                return Device(lockdown=lockdown)
+            else:
+                continue
+    except ConnectionFailedToUsbmuxdError:
+        pass
+
+    logger.debug("waiting for device to be available in Recovery mode")
+    return Device(irecv=IRecv(ecid=ecid))
+
+
+DeviceDep = Annotated[
+    Device,
+    Depends(device_dependency),
+]
 
 
 @contextlib.contextmanager
-def tempzip_download_ctx(url: str) -> Generator[ZipFile, None, None]:
+def tempzip_download_ctx(url: str) -> Iterator[ZipFile]:
     with tempfile.TemporaryDirectory() as tmpdir:
         tmpzip = Path(tmpdir) / url.split("/")[-1]
         file_download(url, tmpzip)
@@ -81,33 +94,52 @@ def tempzip_download_ctx(url: str) -> Generator[ZipFile, None, None]:
 
 
 @contextlib.contextmanager
-def zipfile_ctx(path: str) -> Generator[ZipFile, None, None]:
+def zipfile_ctx(path: str) -> Iterator[ZipFile]:
     yield ZipFile(path)
 
 
-class IPSWCommand(Command):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.params.extend([
-            click.Option(("ipsw_ctx", "-i", "--ipsw"), required=False, callback=self.ipsw_ctx, help="local IPSW file"),
-            click.Option(("tss", "--tss"), type=click.File("rb"), callback=self.tss),
-        ])
+def ipsw_ctx_dependency(
+    device: DeviceDep,
+    ipsw: Annotated[
+        Optional[str],
+        typer.Option(
+            "--ipsw",
+            "-i",
+            help="Path or URL to an IPSW. If omitted, choose a signed build interactively.",
+        ),
+    ] = None,
+) -> contextlib.AbstractContextManager[ZipFile]:
+    if ipsw and not ipsw.startswith(("http://", "https://")):
+        return zipfile_ctx(ipsw)
+
+    url = ipsw
+    if url is None:
+        url = query_ipswme(device.product_type)
+    return tempzip_download_ctx(url)
+
+
+IPSWCtxDep = Annotated[
+    contextlib.AbstractContextManager[ZipFile],
+    Depends(ipsw_ctx_dependency),
+]
 
-    @staticmethod
-    def ipsw_ctx(ctx, param, value) -> Generator[ZipFile, None, None]:
-        if value and not value.startswith(("http://", "https://")):
-            return zipfile_ctx(value)
 
-        url = value
-        if url is None:
-            url = query_ipswme(ctx.params["device"].product_type)
-        return tempzip_download_ctx(url)
+def tss_dependency(
+    tss: Annotated[
+        Optional[Path],
+        typer.Option(help="Path to SHSH blob plist to use for signing requests."),
+    ] = None,
+) -> None:
+    if tss is None:
+        return
+    with tss.open("rb") as tss_file:
+        return plistlib.load(tss_file)
 
-    @staticmethod
-    def tss(ctx, param, value) -> Optional[IO]:
-        if value is None:
-            return
-        return plistlib.load(value)
+
+TSSDep = Annotated[
+    Optional[dict],
+    Depends(tss_dependency),
+]
 
 
 def query_ipswme(identifier: str) -> str:
@@ -118,15 +150,9 @@ def query_ipswme(identifier: str) -> str:
     return firmwares[idx]["url"]
 
 
-async def restore_update_task(device: Device, ipsw: ZipFile, tss: Optional[IO], erase: bool, ignore_fdr: bool) -> None:
-    lockdown = None
-    irecv = None
-    if isinstance(device, LockdownClient):
-        lockdown = device
-    elif isinstance(device, IRecv):
-        irecv = device
-    device = Device(lockdown=lockdown, irecv=irecv)
-
+async def restore_update_task(
+    device: Device, ipsw: ZipFile, tss: Optional[dict], erase: bool, ignore_fdr: bool
+) -> None:
     behavior = Behavior.Update
     if erase:
         behavior = Behavior.Erase
@@ -139,19 +165,8 @@ async def restore_update_task(device: Device, ipsw: ZipFile, tss: Optional[IO],
         raise
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group()
-def restore() -> None:
-    """Restore an IPSW or access device in recovery mode"""
-    pass
-
-
-@restore.command("shell", cls=Command)
-def restore_shell(device):
+@cli.command("shell")
+def restore_shell(device: DeviceDep) -> None:
     """create an IPython shell for interacting with iBoot"""
     IPython.embed(
         header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")),
@@ -161,40 +176,34 @@ def restore_shell(device):
     )
 
 
-@restore.command("enter", cls=Command)
-def restore_enter(device):
+@cli.command("enter")
+def restore_enter(device: DeviceDep) -> None:
     """enter Recovery mode"""
     if isinstance(device, LockdownClient):
         device.enter_recovery()
 
 
-@restore.command("exit")
-def restore_exit():
+@cli.command("exit")
+def restore_exit() -> None:
     """exit Recovery mode"""
     irecv = IRecv()
     irecv.set_autoboot(True)
     irecv.reboot()
 
 
-@restore.command("restart", cls=Command)
-def restore_restart(device):
+@cli.command("restart")
+def restore_restart(device: DeviceDep) -> None:
     """restarts device"""
-    if isinstance(device, LockdownClient):
-        with DiagnosticsService(device) as diagnostics:
+    if device.is_lockdown:
+        with DiagnosticsService(device.lockdown) as diagnostics:
             diagnostics.restart()
     else:
-        device.reboot()
+        device.irecv.reboot()
 
 
-async def restore_tss_task(device: Device, ipsw_ctx: Generator, tss: IO, out: Optional[IO]) -> None:
-    lockdown = None
-    irecv = None
-    if isinstance(device, LockdownClient):
-        lockdown = device
-    elif isinstance(device, IRecv):
-        irecv = device
-
-    device = Device(lockdown=lockdown, irecv=irecv)
+async def restore_tss_task(
+    device: Device, ipsw_ctx: contextlib.AbstractContextManager[ZipFile], out: Optional[IO]
+) -> None:
     with ipsw_ctx as ipsw:
         tss = await Recovery(ipsw, device).fetch_tss_record()
     if out:
@@ -202,46 +211,42 @@ async def restore_tss_task(device: Device, ipsw_ctx: Generator, tss: IO, out: Op
     print_json(tss)
 
 
-@restore.command("tss", cls=IPSWCommand)
-@click.argument("out", type=click.File("wb"), required=False)
-def restore_tss(device: Device, ipsw_ctx: Generator, tss: IO, out: Optional[IO]) -> None:
+@cli.command("tss")
+def restore_tss(device: DeviceDep, ipsw_ctx: IPSWCtxDep, out: Optional[Path] = None) -> None:
     """query SHSH blobs"""
-    asyncio.run(restore_tss_task(device, ipsw_ctx, tss, out), debug=True)
+    with out.open("wb") if out else contextlib.nullcontext() as out_file:
+        asyncio.run(restore_tss_task(device, ipsw_ctx, out_file), debug=True)
 
 
-async def restore_ramdisk_task(device: Device, ipsw_ctx: Generator) -> None:
-    lockdown = None
-    irecv = None
-    if isinstance(device, LockdownClient):
-        lockdown = device
-    elif isinstance(device, IRecv):
-        irecv = device
-    device = Device(lockdown=lockdown, irecv=irecv)
-
+async def restore_ramdisk_task(device: Device, ipsw_ctx: contextlib.AbstractContextManager[ZipFile]) -> None:
     with ipsw_ctx as ipsw:
         await Recovery(ipsw, device).boot_ramdisk()
 
 
-@restore.command("ramdisk", cls=IPSWCommand)
-def restore_ramdisk(device: Device, ipsw_ctx: Generator, tss: IO) -> None:
+@cli.command("ramdisk")
+def restore_ramdisk(device: DeviceDep, ipsw_ctx: IPSWCtxDep) -> None:
     """
-    don't perform an actual restore. just enter the update ramdisk
-
-    ipsw can be either a filename or an url
+    Boot only the update ramdisk without performing a restore (IPSW path or URL accepted).
     """
     asyncio.run(restore_ramdisk_task(device, ipsw_ctx), debug=True)
 
 
-@restore.command("update", cls=IPSWCommand)
-@click.option("--erase", is_flag=True, help="use the Erase BuildIdentity (full factory-reset)")
-@click.option(
-    "--ignore-fdr", is_flag=True, help="only establish an FDR service connection, but don't proxy any traffic"
-)
-def restore_update(device: Device, ipsw_ctx: Generator, tss: IO, erase: bool, ignore_fdr: bool) -> None:
+@cli.command("update")
+def restore_update(
+    device: DeviceDep,
+    ipsw_ctx: IPSWCtxDep,
+    tss: TSSDep,
+    erase: Annotated[
+        bool,
+        typer.Option(help="Erase and restore (factory reset) instead of updating in place."),
+    ] = False,
+    ignore_fdr: Annotated[
+        bool,
+        typer.Option(help="Connect to the FDR service only (debug mode; no traffic proxying)."),
+    ] = False,
+) -> None:
     """
-    perform an update
-
-    ipsw can be either a filename or an url
+    Update or restore the device using an IPSW (local path or URL).
     """
     with ipsw_ctx as ipsw:
         asyncio.run(restore_update_task(device, ipsw, tss, erase, ignore_fdr), debug=True)