Revert "Implement a more robust IPC system between the launcher and client (#4159)"

This reverts commit 5ffcc48.

Author: Prospector

apps/app/src/api/oauth_utils/auth_code_reply.rs

@@ -11,16 +11,18 @@
 //! [RFC 8252]: https://datatracker.ietf.org/doc/html/rfc8252
 
 use std::{
-    net::SocketAddr,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     sync::{LazyLock, Mutex},
     time::Duration,
 };
 
 use hyper::body::Incoming;
 use hyper_util::rt::{TokioIo, TokioTimer};
 use theseus::ErrorKind;
-use theseus::prelude::tcp_listen_any_loopback;
-use tokio::sync::{broadcast, oneshot};
+use tokio::{
+    net::TcpListener,
+    sync::{broadcast, oneshot},
+};
 
 static SERVER_SHUTDOWN: LazyLock<broadcast::Sender<()>> =
     LazyLock::new(|| broadcast::channel(1024).0);
@@ -33,7 +35,17 @@ static SERVER_SHUTDOWN: LazyLock<broadcast::Sender<()>> =
 pub async fn listen(
     listen_socket_tx: oneshot::Sender<Result<SocketAddr, theseus::Error>>,
 ) -> Result<Option<String>, theseus::Error> {
-    let listener = match tcp_listen_any_loopback().await {
+    // IPv4 is tried first for the best compatibility and performance with most systems.
+    // IPv6 is also tried in case IPv4 is not available. Resolving "localhost" is avoided
+    // to prevent failures deriving from improper name resolution setup. Any available
+    // ephemeral port is used to prevent conflicts with other services. This is all as per
+    // RFC 8252's recommendations
+    const ANY_LOOPBACK_SOCKET: &[SocketAddr] = &[
+        SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0),
+        SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 0),
+    ];
+
+    let listener = match TcpListener::bind(ANY_LOOPBACK_SOCKET).await {
         Ok(listener) => {
             listen_socket_tx
                 .send(listener.local_addr().map_err(|e| {

packages/app-lib/build.rs

@@ -53,6 +53,7 @@ fn build_java_jars() {
         .arg("build")
         .arg("--no-daemon")
         .arg("--console=rich")
+        .arg("--info")
         .current_dir(dunce::canonicalize("java").unwrap())
         .status()
         .expect("Failed to wait on Gradle build");

packages/app-lib/java/build.gradle.kts

@@ -11,7 +11,6 @@ repositories {
 dependencies {
     implementation("org.ow2.asm:asm:9.8")
     implementation("org.ow2.asm:asm-tree:9.8")
-    implementation("com.google.code.gson:gson:2.13.1")
 
     testImplementation(libs.junit.jupiter)
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")

packages/app-lib/java/src/main/java/com/modrinth/theseus/MinecraftLaunch.java

@@ -1,33 +1,57 @@
 package com.modrinth.theseus;
 
-import com.modrinth.theseus.rpc.RpcHandlers;
-import com.modrinth.theseus.rpc.TheseusRpc;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
 
 public final class MinecraftLaunch {
     public static void main(String[] args) throws IOException, ReflectiveOperationException {
         final String mainClass = args[0];
         final String[] gameArgs = Arrays.copyOfRange(args, 1, args.length);
 
         System.setProperty("modrinth.process.args", String.join("\u001f", gameArgs));
+        parseInput();
 
-        final CompletableFuture<Void> waitForLaunch = new CompletableFuture<>();
-        TheseusRpc.connectAndStart(
-                System.getProperty("modrinth.internal.ipc.host"),
-                Integer.getInteger("modrinth.internal.ipc.port"),
-                new RpcHandlers()
-                        .handler("set_system_property", String.class, String.class, System::setProperty)
-                        .handler("launch", () -> waitForLaunch.complete(null)));
-
-        waitForLaunch.join();
         relaunch(mainClass, gameArgs);
     }
 
+    private static void parseInput() throws IOException {
+        final ByteArrayOutputStream line = new ByteArrayOutputStream();
+        while (true) {
+            final int b = System.in.read();
+            if (b < 0) {
+                throw new IllegalStateException("Stdin terminated while parsing");
+            }
+            if (b != '\n') {
+                line.write(b);
+                continue;
+            }
+            if (handleLine(line.toString("UTF-8"))) {
+                break;
+            }
+            line.reset();
+        }
+    }
+
+    private static boolean handleLine(String line) {
+        final String[] parts = line.split("\t", 2);
+        switch (parts[0]) {
+            case "property": {
+                final String[] keyValue = parts[1].split("\t", 2);
+                System.setProperty(keyValue[0], keyValue[1]);
+                return false;
+            }
+            case "launch":
+                return true;
+        }
+
+        System.err.println("Unknown input line " + line);
+        return false;
+    }
+
     private static void relaunch(String mainClassName, String[] args) throws ReflectiveOperationException {
         final int javaVersion = getJavaVersion();
         final Class<?> mainClass = Class.forName(mainClassName);

packages/app-lib/java/src/main/java/com/modrinth/theseus/rpc/RpcHandlers.java

@@ -35,9 +35,6 @@ pub mod prelude {
         jre, metadata, minecraft_auth, mr_auth, pack, process,
         profile::{self, Profile, create},
         settings,
-        util::{
-            io::{IOError, canonicalize},
-            network::tcp_listen_any_loopback,
-        },
+        util::io::{IOError, canonicalize},
     };
 }

packages/app-lib/java/src/main/java/com/modrinth/theseus/rpc/RpcMethodException.java

@@ -151,9 +151,6 @@ pub enum ErrorKind {
         "A skin texture must have a dimension of either 64x64 or 64x32 pixels"
     )]
     InvalidSkinTexture,
-
-    #[error("RPC error: {0}")]
-    RpcError(String),
 }
 
 #[derive(Debug)]