fix: update executor and driver server URL state on directConnect

selenium-bridge/src/test/java/io/appium/java_client/selenium/SeleniumBridgeTest.java

@@ -18,6 +18,7 @@
 
 import com.sun.net.httpserver.HttpExchange;
 import com.sun.net.httpserver.HttpServer;
+import io.appium.java_client.AppiumClientConfig;
 import io.appium.java_client.android.AndroidDriver;
 import io.appium.java_client.android.options.UiAutomator2Options;
 import org.junit.jupiter.api.AfterEach;
@@ -37,6 +38,7 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
+import java.net.URI;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
@@ -116,7 +118,7 @@
     }
 
     private AndroidDriver newAppiumDriver() throws IOException {
         return new AndroidDriver(new URL("http://127.0.0.1:" + server.getAddress().getPort()),
                 new UiAutomator2Options().setDeviceName("Android Emulator"));
     }
 
@@ -261,4 +263,23 @@
 
         assertThrows(BiDiException.class, seleniumDriver::getHandle);
     }
+
+    @Test
+    void propagatesDirectConnectServerUrlToSeleniumClientConfig() throws IOException {
+        extraCapabilities = "\"appium:directConnectProtocol\":\"https\","
+                + "\"appium:directConnectHost\":\"203.0.113.1\","
+                + "\"appium:directConnectPort\":4443,"
+                + "\"appium:directConnectPath\":\"/wd/hub\",";
+        var clientConfig = AppiumClientConfig.defaultConfig()
+                .baseUri(URI.create("http://127.0.0.1:" + server.getAddress().getPort()))
+                .directConnect(true);
+        var appiumDriver = new AndroidDriver(clientConfig,
+                new UiAutomator2Options().setDeviceName("Android Emulator"));
+
+        var seleniumDriver = SeleniumBridge.asRemoteWebDriver(appiumDriver);
+
+        assertEquals(URI.create("https://203.0.113.1:4443/wd/hub"),
+                seleniumDriver.getClientConfig().baseUri());
+        seleniumDriver.closeBiDi();
+    }
 }

src/main/java/io/appium/java_client/AppiumDriver.java

@@ -31,7 +31,7 @@
 import io.appium.java_client.remote.options.BaseOptions;
 import io.appium.java_client.service.local.AppiumDriverLocalService;
 import io.appium.java_client.service.local.AppiumServiceBuilder;
-import lombok.Getter;
+import org.jspecify.annotations.Nullable;
 import org.openqa.selenium.Capabilities;
 import org.openqa.selenium.ImmutableCapabilities;
 import org.openqa.selenium.OutputType;
@@ -64,8 +64,7 @@ public class AppiumDriver extends AppiumRemoteWebDriver implements
 
     private static final ErrorHandler ERROR_HANDLER = new ErrorHandler(new ErrorCodesMobile());
     // frequently used command parameters
-    @Getter
-    private final URL remoteAddress;
+    private final @Nullable URL remoteAddress;
     private final ExecuteMethod executeMethod;
 
     /**
@@ -221,6 +220,19 @@ public AppiumDriver(URL remoteSessionAddress, String platformName, String automa
         setSessionId(sessionAddress.getId());
     }
 
+    /**
+     * Gets the remote server address to which commands are sent.
+     *
+     * @return the remote server URL, or {@code null} if not configured
+     */
+    @Nullable
+    public URL getRemoteAddress() {
+        var executor = getCommandExecutor();
+        return executor instanceof AppiumCommandExecutor
+                ? ((AppiumCommandExecutor) executor).getAddressOfRemoteServer()
+                : remoteAddress;
+    }
+
     @Override
     public ExecuteMethod getExecuteMethod() {
         return executeMethod;

src/main/java/io/appium/java_client/remote/AppiumCommandExecutor.java

@@ -55,12 +55,12 @@ public class AppiumCommandExecutor implements CommandExecutor, Closeable {
 
     private final Optional<AppiumDriverLocalService> serviceOptional;
     @Getter
-    private final AppiumClientConfig appiumClientConfig;
-    private final @Nullable URL remoteServer;
+    private volatile AppiumClientConfig appiumClientConfig;
+    private volatile @Nullable URL remoteServer;
     private final Map<String, AppiumCommandInfo> additionalCommands;
     @Getter
     private final Factory httpClientFactory;
-    private HttpClient client;
+    private volatile HttpClient client;
     private @Nullable CommandCodec commandCodec;
     private @Nullable ResponseCodec responseCodec;
 
@@ -78,10 +78,14 @@ public AppiumCommandExecutor(
             @Nullable Factory httpClientFactory,
             AppiumClientConfig appiumClientConfig) {
         this.additionalCommands = new HashMap<>(requireNonNull(additionalCommands, "Additional commands"));
-        this.appiumClientConfig = requireNonNull(appiumClientConfig, "HTTP client configuration");
+        AppiumClientConfig effectiveConfig = requireNonNull(appiumClientConfig, "HTTP client configuration");
+        if (service != null && effectiveConfig.baseUri() == null) {
+            effectiveConfig = effectiveConfig.baseUrl(service.getUrl());
+        }
+        this.appiumClientConfig = effectiveConfig;
         this.httpClientFactory = ofNullable(httpClientFactory).orElseGet(Factory::createDefault);
-        this.client = this.httpClientFactory.createClient(appiumClientConfig);
-        this.remoteServer = appiumClientConfig.baseUrl();
+        this.client = this.httpClientFactory.createClient(effectiveConfig);
+        this.remoteServer = effectiveConfig.baseUrl();
         this.serviceOptional = ofNullable(service);
     }
 
@@ -168,7 +172,7 @@ public AppiumCommandExecutor(Map<String, AppiumCommandInfo> additionalCommands,
      */
     public AppiumCommandExecutor(Map<String, AppiumCommandInfo> additionalCommands,
                                  AppiumDriverLocalService service, AppiumClientConfig appiumClientConfig) {
-        this(additionalCommands, service, Factory.createDefault(), appiumClientConfig);
+        this(additionalCommands, requireNonNull(service), Factory.createDefault(), appiumClientConfig);
     }
 
     /**
@@ -240,9 +244,12 @@ public HttpClient getClient() {
      *                  and other non-special addresses are not rejected by this check.
      */
     protected void overrideServerUrl(URL serverUrl) {
-        DirectConnectUrlSafety.requireSafeOverrideTarget(serverUrl);
-        HttpClient newClient = getHttpClientFactory().createClient(appiumClientConfig.baseUrl(serverUrl));
-        HttpClient oldClient = this.client;
+        DirectConnectUrlSafety.requireSafeOverrideTarget(requireNonNull(serverUrl, "Server URL"));
+        AppiumClientConfig updatedConfig = appiumClientConfig.baseUrl(serverUrl);
+        HttpClient newClient = getHttpClientFactory().createClient(updatedConfig);
+        final HttpClient oldClient = this.client;
+        this.appiumClientConfig = updatedConfig;
+        this.remoteServer = updatedConfig.baseUrl();
         this.client = newClient;
         oldClient.close();
     }
@@ -292,7 +299,7 @@ private void setDirectConnect(Response response) throws SessionNotCreatedExcepti
             return;
         }
 
-        if (!directConnect.getProtocol().equals("https")) {
+        if (!"https".equalsIgnoreCase(directConnect.getProtocol())) {
             throw new SessionNotCreatedException(
                     String.format("The given protocol '%s' as the direct connection url returned by "
                             + "the remote server is not accurate. Only 'https' is supported.",

src/main/java/io/appium/java_client/remote/DirectConnect.java

@@ -23,7 +23,6 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.Map;
-import java.util.Objects;
 import java.util.stream.Stream;
 
 import static io.appium.java_client.internal.CapabilityHelpers.APPIUM_PREFIX;
@@ -65,11 +64,13 @@ private String getDirectConnectValue(Map<String, ?> responseValue, String key) {
     }
 
     /**
-     * Returns true if the {@link DirectConnect} instance member has nonnull values.
-     * @return true if each connection information has a nonnull value
+     * Returns true if the {@link DirectConnect} instance member has valid values.
+     * @return true if protocol, host and port are non-blank and path is non-null
      */
     public boolean isValid() {
-        return Stream.of(this.protocol, this.path, this.host, this.port).noneMatch(Objects::isNull);
+        return this.path != null
+                && Stream.of(this.protocol, this.host, this.port)
+                .allMatch(value -> value != null && !value.isBlank());
     }
 
     /**
@@ -78,15 +79,42 @@ public boolean isValid() {
      * @throws MalformedURLException if the built url was invalid
      */
     public URL getUrl() throws MalformedURLException {
-        String newUrlCandidate = String.format("%s://%s:%s%s", this.protocol, this.host, this.port, this.path);
+        String formattedHost = formatHost(this.host);
+        String normalizedPath = normalizePath(this.path);
+        String newUrlCandidate = String.format("%s://%s:%s%s",
+                this.protocol, formattedHost, this.port, normalizedPath);
+        if (!isValid()) {
+            throw createMalformedUrlException(newUrlCandidate);
+        }
 
         try {
             return new URL(newUrlCandidate);
         } catch (MalformedURLException e) {
-            throw new MalformedURLException(
-                    String.format("The remote server returned an invalid value to build the direct connect URL: %s",
-                            newUrlCandidate)
-            );
+            throw createMalformedUrlException(newUrlCandidate);
+        }
+    }
+
+    private static String formatHost(@Nullable String host) {
+        if (host != null && !host.startsWith("[") && host.indexOf(':') != host.lastIndexOf(':')) {
+            return "[" + host + "]";
+        }
+        return String.valueOf(host);
+    }
+
+    private static String normalizePath(@Nullable String path) {
+        if (path == null) {
+            return "null";
+        }
+        if (path.isEmpty() || path.startsWith("/")) {
+            return path;
         }
+        return "/" + path;
+    }
+
+    private static MalformedURLException createMalformedUrlException(String candidate) {
+        return new MalformedURLException(
+                String.format("The remote server returned an invalid value to build the direct connect URL: %s",
+                        candidate)
+        );
     }
 }

src/test/java/io/appium/java_client/internal/DirectConnectTest.java

@@ -55,5 +55,71 @@ void hasInvalidDirectConnect() {
         Map<String, String> responseValue = new HashMap<>();
         DirectConnect directConnect = new DirectConnect(responseValue);
         assertFalse(directConnect.isValid());
+        assertThrowsExactly(MalformedURLException.class, directConnect::getUrl);
+    }
+
+    @Test
+    void formatsBareIpv6HostAndPreservesBracketedIpv6Host() throws MalformedURLException {
+        Map<String, String> bareIpv6 = Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "2001:db8::1",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", "/wd/hub"
+        );
+        DirectConnect bare = new DirectConnect(bareIpv6);
+        assertTrue(bare.isValid());
+        assertEquals("https://[2001:db8::1]:4443/wd/hub", bare.getUrl().toString());
+
+        Map<String, String> bracketedIpv6 = Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "[2001:db8::1]",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", "/wd/hub"
+        );
+        DirectConnect bracketed = new DirectConnect(bracketedIpv6);
+        assertTrue(bracketed.isValid());
+        assertEquals("https://[2001:db8::1]:4443/wd/hub", bracketed.getUrl().toString());
+    }
+
+    @Test
+    void normalizesEmptyAndRelativeDirectConnectPath() throws MalformedURLException {
+        DirectConnect emptyPath = new DirectConnect(Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "203.0.113.1",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", ""
+        ));
+        assertTrue(emptyPath.isValid());
+        assertEquals("https://203.0.113.1:4443", emptyPath.getUrl().toString());
+
+        DirectConnect relativePath = new DirectConnect(Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "203.0.113.1",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", "wd/hub"
+        ));
+        assertTrue(relativePath.isValid());
+        assertEquals("https://203.0.113.1:4443/wd/hub", relativePath.getUrl().toString());
+    }
+
+    @Test
+    void rejectsSingleColonHostAndBlankFields() {
+        DirectConnect embeddedPortHost = new DirectConnect(Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "evil.example.com:8443",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", "/wd/hub"
+        ));
+        assertTrue(embeddedPortHost.isValid());
+        assertThrowsExactly(MalformedURLException.class, embeddedPortHost::getUrl);
+
+        DirectConnect blankHost = new DirectConnect(Map.of(
+                "appium:directConnectProtocol", "https",
+                "appium:directConnectHost", "   ",
+                "appium:directConnectPort", "4443",
+                "appium:directConnectPath", ""
+        ));
+        assertFalse(blankHost.isValid());
+        assertThrowsExactly(MalformedURLException.class, blankHost::getUrl);
     }
 }