subprojects: Prepare for release

Generic @overload definitions on signal handlers were masking
type-checking errors.

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: frida

examples/open_service/dtx/deviceinfo.py

@@ -0,0 +1,9 @@
+import pprint
+
+import frida
+
+device = frida.get_usb_device()
+
+deviceinfo = device.open_service("dtx:com.apple.instruments.server.services.deviceinfo")
+response = deviceinfo.request({"method": "runningProcesses"})
+pprint.pp(response)

examples/open_service/dtx/opengl.py

@@ -0,0 +1,27 @@
+import sys
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+opengl = device.open_service("dtx:com.apple.instruments.server.services.graphics.opengl")
+opengl.on("message", on_message)
+opengl.request(
+    {
+        "method": "setSamplingRate:",
+        "args": [5.0],
+    }
+)
+opengl.request(
+    {
+        "method": "startSamplingAtTimeInterval:",
+        "args": [0.0],
+    }
+)
+
+sys.stdin.read()

examples/open_service/dtx/processcontrol.py

@@ -0,0 +1,31 @@
+import sys
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+control = device.open_service("dtx:com.apple.instruments.server.services.processcontrol")
+control.on("message", on_message)
+pid = control.request(
+    {
+        "method": "launchSuspendedProcessWithDevicePath:bundleIdentifier:environment:arguments:options:",
+        "args": [
+            "",
+            "no.oleavr.HelloIOS",
+            {},
+            [],
+            {
+                "StartSuspendedKey": False,
+            },
+        ],
+    }
+)
+control.request({"method": "startObservingPid:", "args": [pid]})
+
+print(f"App spawned, PID: {pid}.  Kill it to see an example message being emitted.")
+sys.stdin.read()

examples/open_service/dtx/screenshot.py

@@ -0,0 +1,15 @@
+import sys
+
+import frida
+
+if len(sys.argv) != 2:
+    print(f"Usage: {sys.argv[0]} outfile.png", file=sys.stderr)
+    sys.exit(1)
+outfile = sys.argv[1]
+
+device = frida.get_usb_device()
+
+screenshot = device.open_service("dtx:com.apple.instruments.server.services.screenshot")
+png = screenshot.request({"method": "takeScreenshot"})
+with open(outfile, "wb") as f:
+    f.write(png)

examples/open_service/dtx/sysmontap.py

@@ -0,0 +1,29 @@
+import time
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+sysmon = device.open_service("dtx:com.apple.instruments.server.services.sysmontap")
+sysmon.on("message", on_message)
+sysmon.request(
+    {
+        "method": "setConfig:",
+        "args": [
+            {
+                "ur": 1000,
+                "cpuUsage": True,
+                "sampleInterval": 1000000000,
+            },
+        ],
+    }
+)
+sysmon.request({"method": "start"})
+time.sleep(5)
+sysmon.request({"method": "stop"})
+time.sleep(1)

examples/open_service/plist.py

@@ -0,0 +1,7 @@
+import frida
+
+device = frida.get_usb_device()
+
+diag = device.open_service("plist:com.apple.mobile.diagnostics_relay")
+diag.request({"type": "query", "payload": {"Request": "Sleep", "WaitForDisconnect": True}})
+diag.request({"type": "query", "payload": {"Request": "Goodbye"}})

examples/open_service/xpc/launchapplication.py

@@ -0,0 +1,64 @@
+import pprint
+import sys
+from threading import Thread
+
+import frida
+
+
+def main():
+    device = frida.get_usb_device()
+
+    stdout_uuid, stdout_stream = create_stdio_socket(device)
+    stderr_uuid, stderr_stream = create_stdio_socket(device)
+
+    appservice = device.open_service("xpc:com.apple.coredevice.appservice")
+    response = appservice.request(
+        {
+            "CoreDevice.featureIdentifier": "com.apple.coredevice.feature.launchapplication",
+            "CoreDevice.action": {},
+            "CoreDevice.input": {
+                "applicationSpecifier": {
+                    "bundleIdentifier": {"_0": "no.oleavr.HelloIOS"},
+                },
+                "options": {
+                    "arguments": [],
+                    "environmentVariables": {},
+                    "standardIOUsesPseudoterminals": True,
+                    "startStopped": False,
+                    "terminateExisting": True,
+                    "user": {"active": True},
+                    "platformSpecificOptions": b'<?xml version="1.0" encoding="UTF-8"?><plist version="1.0"><dict/></plist>',
+                },
+                "standardIOIdentifiers": {
+                    "standardOutput": ("uuid", stdout_uuid),
+                    "standardError": ("uuid", stderr_uuid),
+                },
+            },
+        }
+    )
+    pprint.pp(response)
+
+    workers = set()
+    for stream, sink in {(stdout_stream, sys.stdout), (stderr_stream, sys.stderr)}:
+        t = Thread(target=process_console_output, args=(stream, sink))
+        t.start()
+        workers.add(t)
+    for worker in workers:
+        worker.join()
+
+
+def create_stdio_socket(device):
+    stream = device.open_channel("tcp:com.apple.coredevice.openstdiosocket")
+    return (stream.read_all(16), stream)
+
+
+def process_console_output(stream, sink):
+    while True:
+        chunk = stream.read(4096)
+        if not chunk:
+            break
+        sink.write(chunk.decode("utf-8"))
+
+
+if __name__ == "__main__":
+    main()

examples/open_service/xpc/listprocesses.py

@@ -0,0 +1,15 @@
+import pprint
+
+import frida
+
+device = frida.get_usb_device()
+
+appservice = device.open_service("xpc:com.apple.coredevice.appservice")
+response = appservice.request(
+    {
+        "CoreDevice.featureIdentifier": "com.apple.coredevice.feature.listprocesses",
+        "CoreDevice.action": {},
+        "CoreDevice.input": {},
+    }
+)
+pprint.pp(response)

frida/__init__.py

@@ -23,6 +23,7 @@ Relay = _frida.Relay
 PortalService = core.PortalService
 EndpointParameters = core.EndpointParameters
 Compiler = core.Compiler
+PackageManager = core.PackageManager
 FileMonitor = _frida.FileMonitor
 Cancellable = core.Cancellable
 

frida/_frida/__init__.pyi

@@ -342,6 +342,12 @@ class Device(Object):
         """
         ...
 
+    def open_service(self, address: str) -> Service:
+        """
+        Open a device-specific service.
+        """
+        ...
+
     def unpair(self) -> None:
         """
         Unpair device.
@@ -629,6 +635,25 @@ class Script(Object):
         """
         ...
 
+class Service(Object):
+    def activate(self) -> None:
+        """
+        Activate the service.
+        """
+        ...
+
+    def cancel(self) -> None:
+        """
+        Cancel the service.
+        """
+        ...
+
+    def request(self, parameters: Any) -> Any:
+        """
+        Perform a request.
+        """
+        ...
+
 class Session(Object):
     @property
     def pid(self) -> int:
@@ -729,8 +754,13 @@ class Compiler(Object):
         self,
         entrypoint: str,
         project_root: Optional[str] = None,
+        output_format: Optional[str] = None,
+        bundle_format: Optional[str] = None,
+        type_check: Optional[str] = None,
         source_maps: Optional[str] = None,
         compression: Optional[str] = None,
+        platform: Optional[str] = None,
+        externals: Optional[Sequence[str]] = None,
     ) -> str:
         """
         Build an agent.
@@ -741,12 +771,107 @@ class Compiler(Object):
         self,
         entrypoint: str,
         project_root: Optional[str] = None,
+        output_format: Optional[str] = None,
+        bundle_format: Optional[str] = None,
+        type_check: Optional[str] = None,
         source_maps: Optional[str] = None,
         compression: Optional[str] = None,
+        platform: Optional[str] = None,
+        externals: Optional[Sequence[str]] = None,
     ) -> None:
         """
         Continuously build an agent.
         """
         ...
 
+class PackageManager(Object):
+    @property
+    def registry(self) -> str:
+        """
+        The registry being used.
+        """
+        ...
+
+    @registry.setter
+    def registry(self, value: str) -> None:
+        """
+        Change the registry to use.
+        """
+        ...
+
+    def search(
+        self,
+        query: str,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> PackageSearchResult:
+        """
+        Search for packages to install.
+        """
+        ...
+
+    def install(
+        self,
+        project_root: Optional[str] = None,
+        role: Optional[str] = None,
+        specs: Optional[Sequence[str]] = None,
+        omits: Optional[Sequence[str]] = None,
+    ) -> PackageInstallResult:
+        """
+        Install one or more packages.
+        """
+        ...
+
+class Package(Object):
+    @property
+    def name(self) -> str:
+        """
+        Package name.
+        """
+        ...
+
+    @property
+    def version(self) -> str:
+        """
+        Package version.
+        """
+        ...
+
+    @property
+    def description(self) -> Optional[str]:
+        """
+        Package description.
+        """
+        ...
+
+    @property
+    def url(self) -> Optional[str]:
+        """
+        Package URL.
+        """
+        ...
+
+class PackageSearchResult(Object):
+    @property
+    def packages(self) -> List[Package]:
+        """
+        Batch of matching packages.
+        """
+        ...
+
+    @property
+    def total(self) -> int:
+        """
+        Total matching packages.
+        """
+        ...
+
+class PackageInstallResult(Object):
+    @property
+    def packages(self) -> List[Package]:
+        """
+        The toplevel packages that are installed.
+        """
+        ...
+
 __version__: str

frida/core.py

@@ -33,10 +33,15 @@ if sys.version_info >= (3, 8):
 else:
     from typing_extensions import Literal, TypedDict
 
-if sys.version_info >= (3, 11):
-    from typing import NotRequired
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
 else:
-    from typing_extensions import NotRequired
+    from typing_extensions import ParamSpec
+
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, cast
+else:
+    from typing_extensions import NotRequired, cast
 
 from . import _frida
 
@@ -72,15 +77,18 @@ def _filter_missing_kwargs(d: MutableMapping[Any, Any]) -> None:
             d.pop(key)
 
 
-R = TypeVar("R")
+P = ParamSpec("P")
+R = TypeVar("R", covariant=True)
 
 
-def cancellable(f: Callable[..., R]) -> Callable[..., R]:
+def cancellable(f: Callable[P, R]) -> Callable[P, R]:
+    # currently there is no way to type properly the extended callable with optional cancellable parameter
+    # ref: https://github.com/python/typing/discussions/1905#discussioncomment-11696995
     @functools.wraps(f)
-    def wrapper(*args: Any, **kwargs: Any) -> R:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         cancellable = kwargs.pop("cancellable", None)
         if cancellable is not None:
-            with cancellable:
+            with cast(Cancellable, cancellable):
                 return f(*args, **kwargs)
 
         return f(*args, **kwargs)
@@ -176,7 +184,8 @@ class ScriptExportsSync:
         js_name = _to_camel_case(name)
 
         def method(*args: Any, **kwargs: Any) -> Any:
-            return script._rpc_request("call", js_name, args, **kwargs)
+            request, data = make_rpc_call_request(js_name, args)
+            return script._rpc_request(request, data, **kwargs)
 
         return method
 
@@ -202,7 +211,8 @@ class ScriptExportsAsync:
         js_name = _to_camel_case(name)
 
         async def method(*args: Any, **kwargs: Any) -> Any:
-            return await script._rpc_request_async("call", js_name, args, **kwargs)
+            request, data = make_rpc_call_request(js_name, args)
+            return await script._rpc_request_async(request, data, **kwargs)
 
         return method
 
@@ -210,6 +220,16 @@ class ScriptExportsAsync:
         return self._script.list_exports_sync()
 
 
+def make_rpc_call_request(js_name: str, args: Sequence[Any]) -> Tuple[List[Any], Optional[bytes]]:
+    if args and isinstance(args[-1], bytes):
+        raw_args = args[:-1]
+        data = args[-1]
+    else:
+        raw_args = args
+        data = None
+    return (["call", js_name, raw_args], data)
+
+
 class ScriptErrorMessage(TypedDict):
     type: Literal["error"]
     description: str
@@ -339,9 +359,6 @@ class Script:
     @overload
     def on(self, signal: Literal["message"], callback: ScriptMessageCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Add a signal handler
@@ -358,9 +375,6 @@ class Script:
     @overload
     def off(self, signal: Literal["message"], callback: ScriptMessageCallback) -> None: ...
 
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def off(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Remove a signal handler
@@ -404,7 +418,7 @@ class Script:
         Asynchronously list all the exported attributes from the script's rpc
         """
 
-        result = await self._rpc_request_async("list")
+        result = await self._rpc_request_async(["list"])
         assert isinstance(result, list)
         return result
 
@@ -413,7 +427,7 @@ class Script:
         List all the exported attributes from the script's rpc
         """
 
-        result = self._rpc_request("list")
+        result = self._rpc_request(["list"])
         assert isinstance(result, list)
         return result
 
@@ -429,7 +443,7 @@ class Script:
         )
         return self.list_exports_sync()
 
-    def _rpc_request_async(self, *args: Any) -> asyncio.Future[Any]:
+    def _rpc_request_async(self, args: Any, data: Optional[bytes] = None) -> asyncio.Future[Any]:
         loop = asyncio.get_event_loop()
         future: asyncio.Future[Any] = asyncio.Future()
 
@@ -442,14 +456,14 @@ class Script:
         request_id = self._append_pending(on_complete)
 
         if not self.is_destroyed:
-            self._send_rpc_call(request_id, *args)
+            self._send_rpc_call(request_id, args, data)
         else:
             self._on_destroyed()
 
         return future
 
     @cancellable
-    def _rpc_request(self, *args: Any) -> Any:
+    def _rpc_request(self, args: Any, data: Optional[bytes] = None) -> Any:
         result = RPCResult()
 
         def on_complete(value: Any, error: Optional[Union[RPCException, _frida.InvalidOperationError]]) -> None:
@@ -466,7 +480,7 @@ class Script:
         request_id = self._append_pending(on_complete)
 
         if not self.is_destroyed:
-            self._send_rpc_call(request_id, *args)
+            self._send_rpc_call(request_id, args, data)
 
             cancellable = Cancellable.get_current()
             cancel_handler = cancellable.connect(on_cancelled)
@@ -495,10 +509,8 @@ class Script:
             self._pending[request_id] = callback
         return request_id
 
-    def _send_rpc_call(self, request_id: int, *args: Any) -> None:
-        message = ["frida:rpc", request_id]
-        message.extend(args)
-        self.post(message)
+    def _send_rpc_call(self, request_id: int, args: Any, data: Optional[bytes]) -> None:
+        self.post(["frida:rpc", request_id, *args], data)
 
     def _on_rpc_message(self, request_id: int, operation: str, params: List[Any], data: Optional[Any]) -> None:
         if operation in ("ok", "error"):
@@ -509,7 +521,10 @@ class Script:
             value = None
             error = None
             if operation == "ok":
-                value = params[0] if data is None else data
+                if data is not None:
+                    value = (params[1], data) if len(params) > 1 else data
+                else:
+                    value = params[0]
             else:
                 error = RPCException(*params[0:3])
 
@@ -680,34 +695,22 @@ class Session:
         _filter_missing_kwargs(kwargs)
         return PortalMembership(self._impl.join_portal(address, **kwargs))
 
-    @overload
     def on(
         self,
         signal: Literal["detached"],
         callback: SessionDetachedCallback,
-    ) -> None: ...
-
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
-    def on(self, signal: str, callback: Callable[..., Any]) -> None:
+    ) -> None:
         """
         Add a signal handler
         """
 
         self._impl.on(signal, callback)
 
-    @overload
     def off(
         self,
         signal: Literal["detached"],
         callback: SessionDetachedCallback,
-    ) -> None: ...
-
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
-    def off(self, signal: str, callback: Callable[..., Any]) -> None:
+    ) -> None:
         """
         Remove a signal handler
         """
@@ -750,9 +753,6 @@ class Bus:
     @overload
     def on(self, signal: Literal["message"], callback: BusMessageCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Add a signal handler
@@ -769,9 +769,6 @@ class Bus:
     @overload
     def off(self, signal: Literal["message"], callback: BusMessageCallback) -> None: ...
 
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def off(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Remove a signal handler
@@ -792,6 +789,64 @@ class Bus:
                 traceback.print_exc()
 
 
+ServiceCloseCallback = Callable[[], None]
+ServiceMessageCallback = Callable[[Any], None]
+
+
+class Service:
+    def __init__(self, impl: _frida.Service) -> None:
+        self._impl = impl
+
+    @cancellable
+    def activate(self) -> None:
+        """
+        Activate the service
+        """
+
+        self._impl.activate()
+
+    @cancellable
+    def cancel(self) -> None:
+        """
+        Cancel the service
+        """
+
+        self._impl.cancel()
+
+    def request(self, parameters: Any) -> Any:
+        """
+        Perform a request
+        """
+
+        return self._impl.request(parameters)
+
+    @overload
+    def on(self, signal: Literal["close"], callback: ServiceCloseCallback) -> None: ...
+
+    @overload
+    def on(self, signal: Literal["message"], callback: ServiceMessageCallback) -> None: ...
+
+    def on(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Add a signal handler
+        """
+
+        self._impl.on(signal, callback)
+
+    @overload
+    def off(self, signal: Literal["close"], callback: ServiceCloseCallback) -> None: ...
+
+    @overload
+    def off(self, signal: Literal["message"], callback: ServiceMessageCallback) -> None: ...
+
+    def off(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Remove a signal handler
+        """
+
+        self._impl.off(signal, callback)
+
+
 DeviceSpawnAddedCallback = Callable[[_frida.Spawn], None]
 DeviceSpawnRemovedCallback = Callable[[_frida.Spawn], None]
 DeviceChildAddedCallback = Callable[[_frida.Child], None]
@@ -1019,6 +1074,14 @@ class Device:
 
         return IOStream(self._impl.open_channel(address))
 
+    @cancellable
+    def open_service(self, address: str) -> Service:
+        """
+        Open a device-specific service
+        """
+
+        return Service(self._impl.open_service(address))
+
     @cancellable
     def unpair(self) -> None:
         """
@@ -1059,9 +1122,6 @@ class Device:
     @overload
     def on(self, signal: Literal["lost"], callback: DeviceLostCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Add a signal handler
@@ -1093,9 +1153,6 @@ class Device:
     @overload
     def off(self, signal: Literal["lost"], callback: DeviceLostCallback) -> None: ...
 
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def off(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Remove a signal handler
@@ -1213,9 +1270,6 @@ class DeviceManager:
     @overload
     def on(self, signal: Literal["changed"], callback: DeviceManagerChangedCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Add a signal handler
@@ -1232,9 +1286,6 @@ class DeviceManager:
     @overload
     def off(self, signal: Literal["changed"], callback: DeviceManagerChangedCallback) -> None: ...
 
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def off(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Remove a signal handler
@@ -1405,9 +1456,6 @@ class PortalService:
     @overload
     def on(self, signal: Literal["message"], callback: PortalServiceMessageCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
         """
         Add a signal handler
@@ -1469,10 +1517,16 @@ CompilerFinishedCallback = Callable[[], None]
 CompilerOutputCallback = Callable[[str], None]
 CompilerDiagnosticsCallback = Callable[[List[CompilerDiagnostic]], None]
 
+CompilerOutputFormat = Literal["unescaped", "hex-bytes", "c-string"]
+CompilerBundleFormat = Literal["esm", "iife"]
+CompilerTypeCheck = Literal["full", "none"]
+CompilerSourceMaps = Literal["included", "omitted"]
+CompilerCompression = Literal["none", "terser"]
+CompilerPlatform = Literal["neutral", "gum", "browser"]
 
 class Compiler:
     def __init__(self) -> None:
-        self._impl = _frida.Compiler(get_device_manager()._impl)
+        self._impl = _frida.Compiler()
 
     def __repr__(self) -> str:
         return repr(self._impl)
@@ -1482,10 +1536,24 @@ class Compiler:
         self,
         entrypoint: str,
         project_root: Optional[str] = None,
-        source_maps: Optional[str] = None,
-        compression: Optional[str] = None,
+        output_format: Optional[CompilerOutputFormat] = None,
+        bundle_format: Optional[CompilerBundleFormat] = None,
+        type_check: Optional[CompilerTypeCheck] = None,
+        source_maps: Optional[CompilerSourceMaps] = None,
+        compression: Optional[CompilerCompression] = None,
+        platform: Optional[CompilerPlatform] = None,
+        externals: Optional[Sequence[str]] = None,
     ) -> str:
-        kwargs = {"project_root": project_root, "source_maps": source_maps, "compression": compression}
+        kwargs = {
+            "project_root": project_root,
+            "output_format": output_format,
+            "bundle_format": bundle_format,
+            "type_check": type_check,
+            "source_maps": source_maps,
+            "compression": compression,
+            "platform": platform,
+            "externals": externals,
+        }
         _filter_missing_kwargs(kwargs)
         return self._impl.build(entrypoint, **kwargs)
 
@@ -1494,10 +1562,24 @@ class Compiler:
         self,
         entrypoint: str,
         project_root: Optional[str] = None,
-        source_maps: Optional[str] = None,
-        compression: Optional[str] = None,
+        output_format: Optional[CompilerOutputFormat] = None,
+        bundle_format: Optional[CompilerBundleFormat] = None,
+        type_check: Optional[CompilerTypeCheck] = None,
+        source_maps: Optional[CompilerSourceMaps] = None,
+        compression: Optional[CompilerCompression] = None,
+        platform: Optional[CompilerPlatform] = None,
+        externals: Optional[Sequence[str]] = None,
     ) -> None:
-        kwargs = {"project_root": project_root, "source_maps": source_maps, "compression": compression}
+        kwargs = {
+            "project_root": project_root,
+            "output_format": output_format,
+            "bundle_format": bundle_format,
+            "type_check": type_check,
+            "source_maps": source_maps,
+            "compression": compression,
+            "platform": platform,
+            "externals": externals,
+        }
         _filter_missing_kwargs(kwargs)
         return self._impl.watch(entrypoint, **kwargs)
 
@@ -1513,10 +1595,11 @@ class Compiler:
     @overload
     def on(self, signal: Literal["diagnostics"], callback: CompilerDiagnosticsCallback) -> None: ...
 
-    @overload
-    def on(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def on(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Add a signal handler
+        """
+
         self._impl.on(signal, callback)
 
     @overload
@@ -1531,10 +1614,86 @@ class Compiler:
     @overload
     def off(self, signal: Literal["diagnostics"], callback: CompilerDiagnosticsCallback) -> None: ...
 
-    @overload
-    def off(self, signal: str, callback: Callable[..., Any]) -> None: ...
-
     def off(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Remove a signal handler
+        """
+
+        self._impl.off(signal, callback)
+
+
+PackageManagerInstallProgressCallback = Callable[
+    [
+        Literal[
+            "initializing",
+            "preparing-dependencies",
+            "resolving-package",
+            "fetching-resource",
+            "package-already-installed",
+            "downloading-package",
+            "package-installed",
+            "resolving-and-installing-all",
+            "complete",
+        ],
+        float,
+        Optional[str],
+    ],
+    None,
+]
+
+PackageRole = Literal["runtime", "development", "optional", "peer"]
+
+
+class PackageManager:
+    def __init__(self) -> None:
+        self._impl = _frida.PackageManager()
+
+    def __repr__(self) -> str:
+        return repr(self._impl)
+
+    @property
+    def registry(self):
+        return self._impl.registry
+
+    @registry.setter
+    def registry(self, value):
+        self._impl.registry = value
+
+    @cancellable
+    def search(
+        self,
+        query: str,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> _frida.PackageSearchResult:
+        kwargs = {
+            "offset": offset,
+            "limit": limit,
+        }
+        _filter_missing_kwargs(kwargs)
+        return self._impl.search(query, **kwargs)
+
+    @cancellable
+    def install(
+        self,
+        project_root: Optional[str] = None,
+        role: Optional[PackageRole] = None,
+        specs: Optional[Sequence[str]] = None,
+        omits: Optional[Sequence[PackageRole]] = None,
+    ) -> _frida.PackageInstallResult:
+        kwargs: Dict[str, Any] = {
+            "project_root": project_root,
+            "role": role,
+            "specs": specs,
+            "omits": omits,
+        }
+        _filter_missing_kwargs(kwargs)
+        return self._impl.install(**kwargs)
+
+    def on(self, signal: Literal["install-progress"], callback: PackageManagerInstallProgressCallback) -> None:
+        self._impl.on(signal, callback)
+
+    def off(self, signal: Literal["install-progress"], callback: PackageManagerInstallProgressCallback) -> None:
         self._impl.off(signal, callback)
 
 

subprojects/frida-core.wrap

@@ -1,6 +1,6 @@
 [wrap-git]
 url = https://github.com/frida/frida-core.git
-revision = 16.2.4
+revision = 17.5.2
 depth = 1
 
 [provide]

tests/test_rpc.py

@@ -31,19 +31,26 @@ class TestRpc(unittest.TestCase):
             name="test-rpc",
             source="""\
 rpc.exports = {
-    add: function (a, b) {
-        var result = a + b;
+    add(a, b) {
+        const result = a + b;
         if (result < 0)
-          throw new Error("No");
+            throw new Error("No");
         return result;
     },
-    sub: function (a, b) {
+    sub(a, b) {
         return a - b;
     },
-    speak: function () {
-        var buf = Memory.allocUtf8String("Yo");
+    speak() {
+        const buf = Memory.allocUtf8String("Yo");
         return Memory.readByteArray(buf, 2);
-    }
+    },
+    speakWithMetadata() {
+        const buf = Memory.allocUtf8String("Yo");
+        return ['soft', Memory.readByteArray(buf, 2)];
+    },
+    processData(val, data) {
+        return { val, dump: hexdump(data, { header: false }) };
+    },
 };
 """,
         )
@@ -52,7 +59,13 @@ rpc.exports = {
         self.assertEqual(agent.add(2, 3), 5)
         self.assertEqual(agent.sub(5, 3), 2)
         self.assertRaises(Exception, lambda: agent.add(1, -2))
-        self.assertListEqual([x for x in iter(agent.speak())], [0x59, 0x6F])
+        self.assertEqual(agent.speak(), b"\x59\x6f")
+        meta, data = agent.speak_with_metadata()
+        self.assertEqual(meta, "soft")
+        self.assertEqual(data, b"\x59\x6f")
+        result = agent.process_data(1337, b"\x13\x37")
+        self.assertEqual(result["val"], 1337)
+        self.assertEqual(result["dump"], "00000000  13 37                                            .7")
 
     def test_post_failure(self):
         script = self.session.create_script(