pymobiledevice3 6.1.5__tar.gz → 6.2.0__tar.gz

{pymobiledevice3-6.1.5 → pymobiledevice3-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 6.1.5
+Version: 6.2.0
 Summary: Pure python3 implementation for working with iDevices (iPhone, etc...)
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
@@ -21,6 +21,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: construct>=2.9.29
+Requires-Dist: construct-typing>=0.7.0
 Requires-Dist: asn1
 Requires-Dist: click
 Requires-Dist: coloredlogs

{pymobiledevice3-6.1.5 → pymobiledevice3-6.2.0}/misc/understanding_idevice_protocol_layers.md

@@ -287,14 +287,14 @@ pymobiledevice3 developer dvt launch com.apple.mobilesafari
 
 ## DVT
 
-One of the more interesting developer services, is the one exposed by `DTServiceHub`. It is using DTX protocol messages,
+One of the more interesting developer services is the one exposed by `DTServiceHub`. It is using DTX protocol messages,
 but since it mainly wraps and allows access to stuff in `DVTFoundation.framework` we called it DVT in our
 implementation (probably standing for DeveloperTools).
 
 We don't delve too much into this protocol, but we'll say in general it allows us to invoke a whitelist of ObjC methods
 in different ObjC objects. The terminology used by DVT to each such ObjC object is called "channels".
 
-In order to access this different object use the following APIs:
+To access this different object use the following APIs:
 
 ```python
 from pymobiledevice3.lockdown import create_using_usbmux
@@ -313,17 +313,22 @@ dvt_channel = Screenshot(dvt)
 open('/tmp/screen.png', 'wb').write(dvt_channel.get_screenshot())
 ```
 
-Looking for an unimplemented feature/channel? Feel free to play with it (and submit a PR afterwards 🙏) using the
+Looking for an unimplemented feature/channel? Feel free to play with it (and submit a PR afterward 🙏) using the
 following shell:
 
 ```shell
 pymobiledevice3 developer dvt shell
 ```
 
+> **NOTE:** The full list of the methods that can be invoked on a DVT channel can be found by looking at all ObjC
+> classes in `DVTInstrumentsFoundation.framework` implementing the `DTXAllowedRPC` protocol.
+> There is an existing [Anubis rule](https://github.com/netanelc305/anubis/blob/9da337178ebd7e9f168e9df2d82b192eba4f1b30/example_rules.yaml#L14-L17)
+> I use to diff new methods against the existing ones.
+
 ## RemoteXPC
 
 Starting at iOS 17.0, Apple made a large refactor in the manner we all interact with the developer services. There can
-be multiple reasons for that decision, but in general this refactor main key points are:
+be multiple reasons for that decision, but in general these refactor main key points are:
 
 - Create a single standard for interacting with the new lockdown services (XPC Messages, Apple's proprietary IPC)
 - Optimize the protocol for large file transfers (such as the dyld_shared_cache)
@@ -347,7 +352,7 @@ Since all this communication is IP-based, but without any additional exported TC
 help us here. Instead, starting at iOS 16.0, when connecting an iDevice, it exports another non-standard USB-Ethernet
 adapter (with IPv6 link-local address), placing us in a subnet with the device's `remoted`.
 
-As we've said this communication is non-standard, and requires either:
+As we've said, this communication is non-standard and requires either:
 
 - macOS Monterey or higher
 - Special driver on your linux/Windows machine

{pymobiledevice3-6.1.5 → pymobiledevice3-6.2.0}/pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '6.1.5'
-__version_tuple__ = version_tuple = (6, 1, 5)
+__version__ = version = '6.2.0'
+__version_tuple__ = version_tuple = (6, 2, 0)
 
-__commit_id__ = commit_id = 'g332264942'
+__commit_id__ = commit_id = 'g54f93648f'

{pymobiledevice3-6.1.5 → pymobiledevice3-6.2.0}/pymobiledevice3/cli/developer.py

@@ -13,7 +13,7 @@ import sys
 import time
 from collections import namedtuple
 from dataclasses import asdict
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import IO, Optional
 
@@ -419,6 +419,91 @@ def sysmon_process_single(service_provider: LockdownClient, attributes: list[str
     print_json(result)
 
 
+@sysmon_process.command("monitor-single", cls=Command)
+@click.option(
+    "-a",
+    "--attributes",
+    multiple=True,
+    help="filter processes by attribute (key=value). Multiple filters on same attribute use OR logic, different attributes use AND.",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    default=None,
+    help="output file path for JSONL format (optional, defaults to stdout)",
+)
+@click.option(
+    "-i", "--interval", type=click.INT, default=None, help="minimum interval in milliseconds between outputs (optional)"
+)
+@click.option(
+    "-d",
+    "--duration",
+    type=click.INT,
+    default=None,
+    help="maximum duration in milliseconds to run monitoring (optional)",
+)
+def sysmon_process_monitor_single(
+    service_provider: LockdownClient,
+    attributes: list[str],
+    output: Optional[str],
+    interval: Optional[int],
+    duration: Optional[int],
+):
+    """Continuously monitor a single process with comprehensive metrics."""
+    count = 0
+    start_time = None
+
+    # Parse attributes into grouped filters: same attribute uses OR, different attributes use AND
+    parsed_filters: dict[str, list[str]] = {}
+    if attributes:
+        for raw in attributes:
+            key, value = raw.split("=", 1)
+            parsed_filters.setdefault(key, []).append(value)
+
+    def matches_filters(proc: dict) -> bool:
+        """Check if process matches all filter criteria."""
+        if not parsed_filters:
+            return True
+        return all(str(proc.get(key)) in values for key, values in parsed_filters.items())
+
+    with contextlib.ExitStack() as stack:
+        output_file = stack.enter_context(open(output, "w")) if output else None
+
+        dvt = stack.enter_context(DvtSecureSocketProxyService(lockdown=service_provider))
+        sysmon = stack.enter_context(Sysmontap(dvt))
+
+        for process_snapshot in sysmon.iter_processes():
+            count += 1
+
+            if count < 2:
+                continue
+
+            if start_time is None:
+                start_time = time.time()
+
+            if duration is not None:
+                elapsed_ms = (time.time() - start_time) * 1000
+                if elapsed_ms >= duration:
+                    break
+
+            for process in process_snapshot:
+                if not matches_filters(process):
+                    continue
+
+                process["timestamp"] = datetime.now(timezone.utc).isoformat()
+
+                if output_file:
+                    json_output = json.dumps(process, default=default_json_encoder)
+                    output_file.write(json_output + "\n")
+                    output_file.flush()
+                else:
+                    print_json(process)
+
+            if interval:
+                time.sleep(interval / 1000.0)
+
+
 @sysmon.command("system", cls=Command)
 @click.option("-f", "--fields", help='field names splitted by ",".')
 def sysmon_system(service_provider: LockdownClient, fields):