fix(debug-ios): make the CDP proxy pick a free port and survive reconnects (#6177)

* fix(debug-ios): make the CDP proxy pick a free port and survive reconnects

The port check bound localhost while the server binds every interface, and on macOS those do not conflict, so a taken port passed the check and the listen crashed the CLI. The check now tests all four addresses and the proxy moves on if the bind still fails.

The connection lock was released on the connection event, which never fires for a client that drops during the handshake, so every later client timed out until the CLI exited. A late close from a replaced client could also destroy the socket its successor had just received. Connections now run through an in-process queue, and each session only cleans up after itself; a replaced client is closed with a reason.

Also clears the port service's timers, whose number type check never matched in Node, which produced false port warnings.

* fix(debug-ios): only accept debugger connections from this machine and DevTools

The proxy listened on every interface with no origin check, while the debugger can run any code in the app. Anything on the network, or any web page, could connect. It now binds the two loopback addresses and rejects browser origins other than DevTools and localhost.

* fix(debug-ios): clean up and exit when the app's socket closes

The backend close handler cleared the session before closing the WebSocket, so the WebSocket's close handler no longer saw it as current and skipped destroying the socket and exiting without --watch.

* test(net): skip unavailable addresses through vitest's test context

Author: rigor789

lib/common/services/net-service.ts

@@ -48,35 +48,32 @@ export class Net implements INet {
 	}
 
 	public async isPortAvailable(port: number): Promise<boolean> {
-		return new Promise<boolean>((resolve, reject) => {
-			let isResolved = false;
-			const server = net.createServer();
+		// A listener on one address does not stop a bind on another (e.g. the
+		// wildcard next to the loopback), so each of them has to be free.
+		for (const host of ["127.0.0.1", "::1", "0.0.0.0", "::"]) {
+			if (!(await this.canListen(port, host))) {
+				return false;
+			}
+		}
 
-			server.on("error", (err: Error) => {
-				if (!isResolved) {
-					isResolved = true;
-					resolve(false);
-				}
-			});
+		return true;
+	}
 
-			server.once("close", () => {
-				if (!isResolved) {
-					// "close" will be emitted right after "error"
-					isResolved = true;
-					resolve(true);
-				}
-			});
+	private canListen(port: number, host: string): Promise<boolean> {
+		return new Promise<boolean>((resolve) => {
+			const server = net.createServer();
 
-			server.on("listening", (err: Error) => {
-				if (err && !isResolved) {
-					isResolved = true;
-					resolve(true);
-				}
+			server.once("error", (err: NodeJS.ErrnoException) => {
+				// The host has no such address (e.g. IPv6 is disabled), so nothing
+				// can be listening on it either.
+				resolve(err.code === "EADDRNOTAVAIL" || err.code === "EAFNOSUPPORT");
+			});
 
-				server.close();
+			server.once("listening", () => {
+				server.close(() => resolve(true));
 			});
 
-			server.listen(port, "localhost");
+			server.listen(port, host);
 		});
 	}
 

lib/common/test/unit-tests/services/net-service.ts

@@ -1,5 +1,6 @@
 import { Net } from "../../../services/net-service";
 import { assert } from "chai";
+import * as net from "net";
 import { Yok } from "../../../yok";
 import { ErrorsStub, CommonLoggerStub } from "../stubs";
 import { EOL } from "os";
@@ -25,6 +26,43 @@ describe("net", () => {
 		return testInjector;
 	};
 
+	describe("isPortAvailable", () => {
+		const hosts = [undefined, "127.0.0.1", "::1", "0.0.0.0", "::"];
+
+		for (const host of hosts) {
+			it(`returns false for a port taken on ${host || "the default address"}`, async (context: any) => {
+				const service = createTestInjector("darwin").resolve<INet>(Net);
+				const server = net.createServer();
+				const listening = await new Promise<boolean>((resolve) => {
+					server.once("error", () => resolve(false));
+					const onListening = () => resolve(true);
+					host ? server.listen(0, host, onListening) : server.listen(0, onListening);
+				});
+				if (!listening) {
+					context.skip();
+					return;
+				}
+				const { port } = <net.AddressInfo>server.address();
+
+				try {
+					assert.isFalse(await service.isPortAvailable(port));
+				} finally {
+					await new Promise((resolve) => server.close(resolve));
+				}
+			});
+		}
+
+		it("returns true for a free port", async () => {
+			const service = createTestInjector("darwin").resolve<INet>(Net);
+			const server = net.createServer();
+			await new Promise<void>((resolve) => server.listen(0, () => resolve()));
+			const { port } = <net.AddressInfo>server.address();
+			await new Promise((resolve) => server.close(resolve));
+
+			assert.isTrue(await service.isPortAvailable(port));
+		});
+	});
+
 	describe("waitForPortToListen", () => {
 		let execCalledCount = 0;
 		beforeEach(() => {