feat: Make python daemon start tunneld

Author: Berstanio

build.gradle.kts

@@ -16,6 +16,7 @@ java {
 
 dependencies {
     api("org.json:json:20250517")
+    implementation("com.badlogicgames.jnigen:jnigen-commons:3.1.1")
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
 }

src/main/java/io/github/berstanio/pymobiledevice3/daemon/DaemonHandler.java

@@ -1,5 +1,7 @@
 package io.github.berstanio.pymobiledevice3.daemon;
 
+import com.badlogic.gdx.jnigen.commons.HostDetection;
+import com.badlogic.gdx.jnigen.commons.Os;
 import io.github.berstanio.pymobiledevice3.venv.PyInstallation;
 
 import java.io.BufferedReader;
@@ -27,14 +29,14 @@ public class DaemonHandler {
 
 
     public static File getTempDir() {
-        if (System.getProperty("os.name").toLowerCase().contains("windows"))
+        if (HostDetection.os == Os.Windows)
             return BASE_TEMP_DIR_WIN;
         else
             return BASE_TEMP_DIR_UNIX;
     }
 
     public static File getPortFile() {
-        if (System.getProperty("os.name").toLowerCase().contains("windows"))
+        if (HostDetection.os == Os.Windows)
             return WINDOWS_PORT_PATH;
         else
             return UNIX_PORT_PATH;

src/main/java/io/github/berstanio/pymobiledevice3/ipc/PyMobileDevice3IPC.java

@@ -290,13 +290,30 @@ public CompletableFuture<Void> forceKillDaemon() {
         return CompletableFuture.completedFuture(null);
     }
 
+    public CompletableFuture<Boolean> isTunneldRunning() {
+        JSONObject object = new JSONObject();
+        object.put("command", "is_tunneld_running");
+        return createRequest(object, (future, jsonObject) -> {
+            future.complete(jsonObject.getBoolean("result"));
+        });
+    }
+
+    public CompletableFuture<Void> ensureTunneldRunning() {
+        JSONObject object = new JSONObject();
+        object.put("command", "ensure_tunneld_running");
+        return createRequest(object, (future, jsonObject) -> {
+            future.complete(null);
+        });
+    }
+
     public static void main(String[] args) throws IOException {
         PyInstallation installation = PyInstallationHandler.install(new File("build/pyenv/"));
         DaemonHandler.startDaemon(installation);
         try (PyMobileDevice3IPC ipc = new PyMobileDevice3IPC()) {
             //JSONObject object = ipc.decodePList(new File("/Volumes/ExternalSSD/IdeaProjects/MOE-Upstream/moe/samples-java/Calculator/ios/build/moe/xcodebuild/Release-iphoneos/ios.app/Info.plist")).join();
             //System.out.println(object.getString("CFBundleExecutable"));
             //for (DeviceInfo info : ipc.listDevices().join())
+            ipc.ensureTunneldRunning().join();
 
             //CompletableFuture<String> future = ipc.installApp(ipc.getDevice(null).join(), new File("/Volumes/ExternalSSD/IdeaProjects/MOE-Upstream/moe/samples-java/Calculator/ios/build/moe/xcodebuild/Release-iphoneos/ios.app"), InstallMode.UPGRADE, progress -> System.out.println("Progress: " + progress + "%"));
             DeviceInfo info = ipc.getDevice(null).join();

src/main/java/io/github/berstanio/pymobiledevice3/venv/PyInstallationHandler.java

@@ -1,10 +1,14 @@
 package io.github.berstanio.pymobiledevice3.venv;
 
+import com.badlogic.gdx.jnigen.commons.HostDetection;
+import com.badlogic.gdx.jnigen.commons.Os;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 
 public class PyInstallationHandler {
@@ -26,7 +30,8 @@ public static PyInstallation install(File directory) {
                 // Env is valid. Copy files again, just in case
                 copyFiles(directory);
                 installRequirements(directory);
-                return new PyInstallation(venv, new File(venv, PYTHON_PATH), new File(directory, HANDLER_NAME));
+
+                return finalizeInstallation(directory);
             }
             if (!venv.delete())
                 throw new IllegalStateException(venv.getAbsolutePath() + " exists, is invalid and cannot be deleted");
@@ -66,7 +71,38 @@ public static PyInstallation install(File directory) {
 
         installRequirements(directory);
 
-        return new PyInstallation(venv,  new File(venv, PYTHON_PATH), new File(directory, HANDLER_NAME));
+        return finalizeInstallation(directory);
+    }
+
+    private static PyInstallation finalizeInstallation(File directory) {
+        if (HostDetection.os == Os.MacOsX) {
+            // MacOS is dumb and launching tunneld with osascript looses file perm chain.
+            // So if we install venv on external hard drive, it will fail
+            // So we copy to temp dir, so everything has perms on it
+            File temp = copyToTempDir(directory);
+            File tmpVEnv = new File(temp, VENV_NAME);
+            return new PyInstallation(tmpVEnv, new File(tmpVEnv, PYTHON_PATH), new File(temp, HANDLER_NAME));
+        } else {
+            File venv = new File(directory, VENV_NAME);
+            return new PyInstallation(venv, new File(venv, PYTHON_PATH), new File(directory, HANDLER_NAME));
+        }
+    }
+
+    private static File copyToTempDir(File directory) {
+        try {
+            Path tempDir = Files.createTempDirectory("javapymobiledevice3");
+            Path sourceDir = directory.toPath();
+            int code = new ProcessBuilder("rsync", "-a", sourceDir + "/", tempDir + "/")
+                    .inheritIO()
+                    .start()
+                    .waitFor();
+            if (code != 0)
+                throw new IllegalStateException("Failed to copy " + directory.getAbsolutePath() + " to " + tempDir.toAbsolutePath());
+
+            return tempDir.toFile();
+        } catch (IOException | InterruptedException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     private static void copyFiles(File directory) {

src/main/resources/handler.py

@@ -1,23 +1,30 @@
 import atexit
 import json
 import os
+import platform
 import queue
 import select
+import subprocess
 import sys
 import threading
 import traceback
 from pathlib import Path
 import asyncio
 
 from threading import Thread
+from time import sleep
+
+import requests
 from packaging.version import Version
 
 import pymobiledevice3.usbmux as usbmux
 from pymobiledevice3.exceptions import *
+from pymobiledevice3.remote.common import TunnelProtocol
 from pymobiledevice3.services.installation_proxy import InstallationProxyService
 from pymobiledevice3.services.mobile_image_mounter import auto_mount
 from pymobiledevice3.tcp_forwarder import LockdownTcpForwarder, UsbmuxTcpForwarder
-from pymobiledevice3.tunneld.api import get_tunneld_device_by_udid
+from pymobiledevice3.tunneld.api import get_tunneld_device_by_udid, TUNNELD_DEFAULT_ADDRESS
+from pymobiledevice3.tunneld.server import TunneldRunner
 from pymobiledevice3.usbmux import *
 from pymobiledevice3.lockdown import create_using_usbmux
 import plistlib
@@ -200,6 +207,60 @@ def auto_mount_image(id, lockdown, writer):
     write_dispatcher.write_reply(writer, reply)
 
 
+def start_tunneld():
+    if platform.system() == "Darwin":
+        print("Starting tunneld as process")
+        python_executable = sys.executable
+        start_script = f'do shell script "sudo {python_executable} -m pymobiledevice3 remote tunneld" with administrator privileges'
+        print("Running \"" + start_script + "\"")
+        process = subprocess.Popen(['osascript', '-e', start_script], stdout=None, stderr=None)
+        print(f"Started tunneld process with pid {process.pid}")
+    else:
+        print("Starting tunneld as thread")
+        def _worker():
+            TunneldRunner.create(*TUNNELD_DEFAULT_ADDRESS, protocol=TunnelProtocol.DEFAULT)
+
+        webserver_thread = threading.Thread(target=_worker, daemon=True, name="Python-Tunneld")
+        webserver_thread.start()
+
+    for i in range(60):
+        if is_tunneld_running():
+            print("tunneld successfully started")
+            return
+        sleep(1)
+    raise RuntimeError("Failed launching tunneld service")
+
+def is_tunneld_running():
+    try:
+        response = requests.get(f"http://{TUNNELD_DEFAULT_ADDRESS[0]}:{TUNNELD_DEFAULT_ADDRESS[1]}/hello")
+        if response.status_code != 200:
+            raise RuntimeError()
+
+        data = response.json()
+        if data.get("message") != "Hello, I'm alive":
+            raise RuntimeError()
+        # Tunneld seems running happily
+        return True
+    except Exception:
+        return False
+
+def shutdown_tunneld():
+    if is_tunneld_running():
+        try:
+            response = requests.get(f"http://{TUNNELD_DEFAULT_ADDRESS[0]}:{TUNNELD_DEFAULT_ADDRESS[1]}/shutdown")
+            if response.status_code != 200:
+                raise RuntimeError("Status code was " + str(response.status_code))
+            print("tunneld shutdown request successful")
+        except Exception as e:
+            print("Failed tunneld teardown", e)
+
+def ensure_tunneld_running():
+    if not is_tunneld_running():
+        start_tunneld()
+        print("tunneld is not running - starting")
+    else:
+        print("tunneld is already running")
+
 def debugserver_connect(id, lockdown, port, writer):
     try:
         discovery_service = get_tunneld_device_by_udid(lockdown.udid)
@@ -292,7 +353,7 @@ def handle_command(command, writer):
 
         command_type = res['command']
         if command_type == "exit":
-            print("Exciting by request")
+            print("Exiting by request")
             atexit._run_exitfuncs()
             os._exit(0)
         elif command_type == "list_devices":
@@ -317,6 +378,16 @@ def handle_command(command, writer):
         elif command_type == "usbmux_forwarder_close":
             usbmux_forward_close(id, res['local_port'], writer)
             return
+        elif command_type == "ensure_tunneld_running":
+            ensure_tunneld_running()
+            reply = {"id": id, "state": "completed"}
+            write_dispatcher.write_reply(writer, reply)
+            return
+        elif command_type == "is_tunneld_running":
+            res = is_tunneld_running()
+            reply = {"id": id, "state": "completed", "result": res}
+            write_dispatcher.write_reply(writer, reply)
+            return
 
         # Now come the device targetted functions
         device_id = res['device_id']
@@ -355,6 +426,7 @@ def main():
     print(f"Written port {port} to file {path}")
 
     atexit.register(os.remove, path)
+    atexit.register(shutdown_tunneld)
     print(f"Start listening on port {port}")
     while True:
         client_socket, client_address = server.accept()