feat(gradle-server): migrate task transport from gRPC to JSON-RPC over TCP loopback (PR 1/3) (#1863)

* feat(gradle-server): migrate task transport from gRPC to JSON-RPC over TCP loopback

Replace the existing gRPC + Netty HTTP/2 transport for the task server with
LSP4J JSON-RPC over a plain TCP loopback socket. This eliminates the
mid-frame HTTP/2 race (vscode-gradle issue #1815) at its source by removing
the Netty stack from the task-server hot path entirely.

What changes on the gradle-server side
- New package 	ransport.jsonrpc exposing six methods on gradle/ segment:
  getBuild, runBuild, getProjectDependencies, cancelBuild, cancelBuilds,
  executeCommand. Streaming RPCs (getBuild/runBuild) deliver intermediate
  progress through gradle/getBuild/reply and gradle/runBuild/reply
  notifications and complete the JSON-RPC request with the terminal reply.
- Protobuf wire schema (proto/gradle.proto) is reused for payload bytes;
  request/response/notification params carry the base64-encoded proto
  bytes plus a stream id. This keeps the message layer stable across the
  migration and avoids a JSON re-encoding of large progress payloads.
- GradleServer becomes a thin bootstrap: it connects out to the Node
  listener on 127.0.0.1:<port>, builds an LSP4J launcher backed by a
  cached worker pool, and blocks until the socket closes.
- Handlers no longer hold gRPC StreamObservers. Streaming handlers take
  (Request, CompletableFuture<GradleResponse>, GradleClient, long streamId);
  unary handlers take (Request, CompletableFuture<GradleResponse>).

Removed
- io.grpc:grpc-protobuf, grpc-stub, grpc-netty (plus grpc-testing)
  dependencies, the protoc-gen-grpc-java plugin, and the
  �uild/generated/source/proto/main/grpc source set.
- TaskService (gRPC service shim) and ErrorMessageBuilder (only used
  by the gRPC error path).
- The Netty HTTP/2 mid-frame log filter and its tests
  (GradleServerFilterTest).
- Forced
etty-bom pin (no longer relevant since Netty is gone from
  the task-server runtime).

Tests
- GradleServerTest now exercises handlers directly via
  CompletableFuture<GradleResponse> and a Mockito-mocked GradleClient,
  so the test surface verifies Gradle Tooling API interactions without
  spinning up a gRPC InProcess channel.
- One extra --add-opens (java.util.concurrent) is added to the test
  JVM args so PowerMock can introspect CompletableFuture on JDK 17+.

This commit is the gradle-server half of the migration. The TypeScript
extension still speaks gRPC and is updated in PR 2; the proto files and
the root-build grpcVersion constant are cleaned up in PR 3.

* test(gradle-server): cover JSON-RPC transport with end-to-end roundtrip tests

Add JsonRpcTransportTest exercising the new transport package end-to-end
over a pair of piped streams. Two Launcher instances are wired together
(server side: GradleService stub + GradleClient remote proxy; client
side: recording GradleClient + GradleService remote proxy) so the full
request/response/notification path is driven without a real socket and
without a dependency on the Gradle Tooling API.

Coverage:
- Base64 protobuf encode/decode roundtrip via JsonRpcCodec.
- All six RPC methods (getBuild, 
unBuild, getProjectDependencies,
  cancelBuild, cancelBuilds, �xecuteCommand) — payload identity,
  stream-id propagation, and null 
eply handling.
- Streaming notifications: getBuild/reply carries the right stream id
  and payload to the client side; 
unBuild/reply is delivered on the
  separate 
unBuild notification channel without leaking into the
  getBuild channel.
- Error mapping across the wire for ResponseErrorException produced by
  JsonRpcCodec.error(...) — covers NOT_FOUND, CANCELLED and
  INTERNAL (the last one via a Throwable carrier).
- Pinned constants for the four error codes that form part of the wire
  contract with the TS client, to catch accidental renumbering.

The handler-level behaviour (Gradle Tooling API interaction, debug init
script, JVM args, etc.) stays covered by GradleServerTest, which talks
to handlers directly via CompletableFuture<GradleResponse> rather than
through the JSON-RPC dispatch layer — so the two test classes between
them cover the wire layer and the business logic without overlapping.

* fix: update the review comments

* fix(gradle-server): address Copilot review comments on PR #1863

- GradleServiceImpl: validate JSON-RPC params/request nullability and map
  Base64 decode errors to ERROR_UNKNOWN instead of ERROR_INTERNAL so
  client-side input bugs surface with the correct wire code.
- ExecuteCommandHandler: split error replies so unknown commands return
  ERROR_NOT_FOUND and argument-count violations return ERROR_UNKNOWN;
  reserve ERROR_INTERNAL for genuine server failures.
- GradleServer: extract a workerThreadFactory() that hands out unique
  `gradle-jsonrpc-worker-N` names via AtomicInteger so concurrent
  handlers are distinguishable in thread dumps and logs.

Adds regression coverage:
- JsonRpcTransportTest: 4 new tests for null params, null request,
  invalid Base64, and null cancelBuilds params.
- ExecuteCommandHandlerTest (new): 4 tests covering the new error code
  mapping plus the happy path.
- GradleServerThreadFactoryTest (new): 3 tests covering unique naming,
  daemon flag, and per-instance counter isolation.

* perf: improve sync lock and order code

* perf: error code

* chore: ignore local-only *.local.md working notes

Author: wenytang-ms

.gitignore

@@ -33,3 +33,6 @@ gradle-server/src/main/resources/*.jar
 
 # Ignore user-specified .tool-versions file (asdf-vm configuration)
 .tool-versions
+
+# Local-only working notes (never commit)
+*.local.md

gradle-server/build.gradle

@@ -18,22 +18,18 @@ repositories {
 }
 
 dependencies {
-  implementation enforcedPlatform('io.netty:netty-bom:4.1.130.Final')
   implementation project(":gradle-plugin-api")
   implementation files('build/libs/server.jar')
   implementation fileTree(dir: 'build/libs/runtime', include: ['*.jar'], exclude: ['gradle-tooling-api-*.jar',
   'slf4j-api-*.jar'])
   implementation("org.gradle:gradle-tooling-api:${toolingAPIVersion}")
   implementation 'javax.annotation:javax.annotation-api:1.3.2'
-  implementation "io.grpc:grpc-protobuf:${grpcVersion}"
-  implementation "io.grpc:grpc-stub:${grpcVersion}"
-  implementation "io.grpc:grpc-netty:${grpcVersion}"
+  implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
   implementation 'io.github.g00fy2:versioncompare:1.4.1'
   implementation project(':gradle-language-server')
   implementation "org.eclipse.lsp4j:org.eclipse.lsp4j:0.24.0"
   implementation "org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:0.24.0"
   runtimeOnly 'org.slf4j:slf4j-simple:2.0.0-alpha6'
-  testImplementation "io.grpc:grpc-testing:${grpcVersion}"
   testImplementation 'junit:junit:4.13.1'
   testImplementation 'org.powermock:powermock-module-junit4:2.0.9'
   testImplementation 'org.powermock:powermock-api-mockito2:2.0.7'
@@ -51,7 +47,6 @@ sourceSets {
     }
     java {
       srcDirs mainJavaDir
-      srcDirs 'build/generated/source/proto/main/grpc'
       srcDirs 'build/generated/source/proto/main/java'
     }
     resources {
@@ -61,25 +56,12 @@ sourceSets {
 }
 
 protobuf {
-  plugins {
-    grpc {
-      // for apple m1, please add protoc_platform=osx-x86_64 in $HOME/.gradle/gradle.properties
-      if (project.hasProperty('protoc_platform')) {
-        artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}:${protoc_platform}"
-      } else {
-        artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
-      }
-    }
-  }
   generateProtoTasks {
     generateTestProto.enabled = false
     extractProto.enabled = false;
     extractIncludeProto.enabled = false;
     extractIncludeTestProto.enabled = false;
     all().each { task ->
-      task.plugins {
-        grpc {}
-      }
       task.builtins {
         remove distribution
       }
@@ -157,6 +139,7 @@ project.tasks.named("processResources") {
 test {
     jvmArgs '--add-opens=java.base/java.lang=ALL-UNNAMED',
     '--add-opens=java.base/java.util=ALL-UNNAMED',
+    '--add-opens=java.base/java.util.concurrent=ALL-UNNAMED',
     '--add-opens=java.base/java.lang.reflect=ALL-UNNAMED',
     '--add-opens=java.base/java.nio.file=ALL-UNNAMED',
     '--add-opens=java.base/java.io=ALL-UNNAMED',

gradle-server/src/main/java/com/github/badsyntax/gradle/ErrorMessageBuilder.java

@@ -1,71 +1,24 @@
 package com.github.badsyntax.gradle;
 
+import com.github.badsyntax.gradle.transport.jsonrpc.TaskSocketServer;
 import com.github.badsyntax.gradle.utils.Utils;
 import com.google.common.base.Strings;
 import com.microsoft.gradle.GradleLanguageServer;
-import io.grpc.Server;
-import io.grpc.ServerBuilder;
-import io.grpc.StatusRuntimeException;
-import io.grpc.netty.NettyServerBuilder;
-import java.io.IOException;
-import java.net.InetSocketAddress;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Filter;
-import java.util.logging.Handler;
-import java.util.logging.Level;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class GradleServer {
 	private static final Logger logger = LoggerFactory.getLogger(GradleServer.class.getName());
 
-	private final int port;
-	private final Server taskServer;
-
-	public GradleServer(int port) {
-		this(NettyServerBuilder.forAddress(new InetSocketAddress("127.0.0.1", port)), port);
-	}
-
-	public GradleServer(ServerBuilder<?> serverBuilder, int port) {
-		this.port = port;
-		taskServer = serverBuilder.addService(new TaskService()).build();
-	}
-
-	@SuppressWarnings("java:S106")
-	public void start() throws IOException {
-		taskServer.start();
-		logger.info("Gradle Server started, listening on {}", port);
-		Runtime.getRuntime().addShutdownHook(new Thread() {
-			@Override
-			public void run() {
-				logger.info("Shutting down gRPC server since JVM is shutting down");
-				try {
-					GradleServer.this.stop();
-				} catch (InterruptedException e) {
-					e.printStackTrace(System.err);
-					Thread.currentThread().interrupt();
-				}
-				logger.info("Server shut down");
-			}
-		});
-	}
-
-	public void stop() throws InterruptedException {
-		if (taskServer != null) {
-			taskServer.shutdown().awaitTermination(30, TimeUnit.SECONDS);
-		}
-	}
-
-	private void blockUntilShutdown() throws InterruptedException {
-		if (taskServer != null) {
-			taskServer.awaitTermination();
-		}
+	private GradleServer() {
 	}
 
 	public static void main(String[] args) throws Exception {
-		installNettyMidFrameWarningFilter();
-
 		Map<String, String> params = Utils.parseArgs(args);
 
 		int taskServerPort = Integer.parseInt(Utils.validateRequiredParam(params, "port"));
@@ -84,63 +37,30 @@ public static void main(String[] args) throws Exception {
 		}
 	}
 
-	/**
-	 * The client retries once on the known Node.js http2 race that produces a
-	 * truncated DATA + END_STREAM frame when reusing an HTTP/2 session (tracked
-	 * upstream as grpc/grpc-node#2872; maintainers attribute the root cause to Node
-	 * and recommend application-level retry). When this happens, grpc-netty logs an
-	 * INTERNAL "Encountered end-of-stream mid-frame" WARNING with a long stack
-	 * trace to stderr, which surfaces in the extension output channel as a scary
-	 * error even though the retried call succeeded. Filter that single record out
-	 * of every JUL handler attached to the root logger; the filter checks the log
-	 * level, the logger name, the throwable type and the message text, so all other
-	 * Netty warnings (TLS, protocol violations, etc.) and any record at a different
-	 * level (e.g. SEVERE) pass through unchanged. If a handler already had a filter
-	 * configured, the existing filter is preserved and chained so we never silently
-	 * bypass other logging policies.
-	 */
-	private static void installNettyMidFrameWarningFilter() {
-		Filter suppression = buildNettyMidFrameWarningFilter();
-		java.util.logging.Logger root = java.util.logging.Logger.getLogger("");
-		for (Handler h : root.getHandlers()) {
-			Filter previous = h.getFilter();
-			h.setFilter(composeFilters(previous, suppression));
-		}
-	}
-
-	// Package-private for testing.
-	static Filter buildNettyMidFrameWarningFilter() {
-		return record -> {
-			if (!Level.WARNING.equals(record.getLevel())) {
-				return true;
-			}
-			Throwable t = record.getThrown();
-			String name = record.getLoggerName();
-			return !(name != null && name.startsWith("io.grpc.netty.NettyServerStream")
-					&& t instanceof StatusRuntimeException && t.getMessage() != null
-					&& t.getMessage().contains("Encountered end-of-stream mid-frame"));
-		};
-	}
-
-	// Package-private for testing.
-	static Filter composeFilters(Filter previous, Filter next) {
-		if (previous == null) {
-			return next;
-		}
-		return record -> previous.isLoggable(record) && next.isLoggable(record);
-	}
-
 	private static void startTaskServerThread(int port) {
-		GradleServer server = new GradleServer(port);
+		ExecutorService workerExecutor = Executors.newCachedThreadPool(workerThreadFactory());
 		Thread serverThread = new Thread(() -> {
+			int exitCode = 0;
 			try {
-				server.start();
-				server.blockUntilShutdown();
-			} catch (IOException | InterruptedException e) {
-				throw new RuntimeException(e);
+				Future<Void> listening = TaskSocketServer.connectAndStart(port, workerExecutor);
+				logger.info("Gradle Server JSON-RPC transport connected on loopback port {}", port);
+				listening.get();
+				logger.info("Gradle Server JSON-RPC transport closed");
+			} catch (Exception e) {
+				exitCode = 1;
+				logger.error("Gradle Server JSON-RPC transport failed", e);
+			} finally {
+				workerExecutor.shutdownNow();
 			}
-		});
+			logger.info("Exiting Gradle Server JVM because JSON-RPC task transport ended");
+			System.exit(exitCode);
+		}, "gradle-jsonrpc-server");
 		serverThread.start();
+
+		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+			logger.info("Shutting down Gradle Server JSON-RPC transport since JVM is shutting down");
+			workerExecutor.shutdownNow();
+		}, "gradle-jsonrpc-shutdown"));
 	}
 
 	private static void startBuildServerThread(String pipeName, String directory) {
@@ -155,4 +75,19 @@ private static void startLanguageServerThread(String languageServerPipePath) {
 		});
 		languageServerThread.start();
 	}
+
+	/**
+	 * Worker thread factory: gives every JSON-RPC worker thread a unique name
+	 * (suffixed with a monotonic counter) so thread dumps and logs can distinguish
+	 * concurrent handlers. Daemon threads so they don't keep the JVM alive past
+	 * {@link #main(String[])}. Package-private for testing.
+	 */
+	static java.util.concurrent.ThreadFactory workerThreadFactory() {
+		AtomicInteger counter = new AtomicInteger();
+		return runnable -> {
+			Thread t = new Thread(runnable, "gradle-jsonrpc-worker-" + counter.incrementAndGet());
+			t.setDaemon(true);
+			return t;
+		};
+	}
 }

gradle-server/src/main/java/com/github/badsyntax/gradle/GradleServer.java

@@ -4,19 +4,21 @@
 import com.github.badsyntax.gradle.CancelBuildRequest;
 import com.github.badsyntax.gradle.GradleBuildCancellation;
 import com.github.badsyntax.gradle.exceptions.GradleCancellationException;
-import io.grpc.stub.StreamObserver;
+import com.github.badsyntax.gradle.transport.jsonrpc.GradleResponse;
+import com.github.badsyntax.gradle.transport.jsonrpc.JsonRpcCodec;
+import java.util.concurrent.CompletableFuture;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class CancelBuildHandler {
 	private static final Logger logger = LoggerFactory.getLogger(CancelBuildHandler.class.getName());
 
 	private CancelBuildRequest req;
-	private StreamObserver<CancelBuildReply> responseObserver;
+	private CompletableFuture<GradleResponse> response;
 
-	public CancelBuildHandler(CancelBuildRequest req, StreamObserver<CancelBuildReply> responseObserver) {
+	public CancelBuildHandler(CancelBuildRequest req, CompletableFuture<GradleResponse> response) {
 		this.req = req;
-		this.responseObserver = responseObserver;
+		this.response = response;
 	}
 
 	public void run() {
@@ -26,18 +28,18 @@ public void run() {
 		} catch (GradleCancellationException e) {
 			logger.error(e.getMessage());
 			replyWithCancelError(e);
-		} finally {
-			responseObserver.onCompleted();
 		}
 	}
 
 	private void replyWithCancelledSuccess() {
-		responseObserver.onNext(
-				CancelBuildReply.newBuilder().setMessage("Cancel build requested").setBuildRunning(true).build());
+		CancelBuildReply reply = CancelBuildReply.newBuilder().setMessage("Cancel build requested")
+				.setBuildRunning(true).build();
+		response.complete(new GradleResponse(JsonRpcCodec.encode(reply)));
 	}
 
 	private void replyWithCancelError(Exception e) {
-		responseObserver
-				.onNext(CancelBuildReply.newBuilder().setMessage(e.getMessage()).setBuildRunning(false).build());
+		CancelBuildReply reply = CancelBuildReply.newBuilder().setMessage(e.getMessage()).setBuildRunning(false)
+				.build();
+		response.complete(new GradleResponse(JsonRpcCodec.encode(reply)));
 	}
 }