[grid] honor client-advertised se:remoteUrl for reachable BiDi/CDP/VNC URLs

dotnet/src/webdriver/Remote/HttpCommandExecutor.cs

@@ -111,6 +111,11 @@ public HttpCommandExecutor(Uri addressOfRemoteServer, TimeSpan timeout, bool ena
     /// </summary>
     public string UserAgent { get; set; }
 
+    /// <summary>
+    /// Gets the address of the remote end this executor connects to.
+    /// </summary>
+    internal Uri RemoteServerUri => this.remoteServerUri;
+
     /// <summary>
     /// Gets the repository of objects containing information about commands.
     /// </summary>

dotnet/src/webdriver/WebDriver.cs

@@ -604,6 +604,11 @@ protected void StartSession(ICapabilities capabilities)
         {
             Dictionary<string, object> matchCapabilities = this.GetCapabilitiesDictionary(capabilities);
 
+            if (this.CommandExecutor is Remote.HttpCommandExecutor httpExecutor)
+            {
+                matchCapabilities["se:remoteUrl"] = httpExecutor.RemoteServerUri.AbsoluteUri;
+            }
+
             List<object> firstMatchCapabilitiesList = new List<object>();
             firstMatchCapabilitiesList.Add(matchCapabilities);
 

java/src/org/openqa/selenium/grid/node/local/LocalNode.java

@@ -145,6 +145,7 @@ public class LocalNode extends Node implements Closeable {
   private final EventBus bus;
   private final URI externalUri;
   private final URI gridUri;
+  private final boolean gridUrlSpecified;
   private final Duration heartbeatPeriod;
   private final HealthCheck healthCheck;
   private final int maxSessionCount;
@@ -175,6 +176,7 @@ protected LocalNode(
       EventBus bus,
       URI uri,
       URI gridUri,
+      boolean gridUrlSpecified,
       @Nullable HealthCheck healthCheck,
       int maxSessionCount,
       int drainAfterSessionCount,
@@ -200,6 +202,7 @@ protected LocalNode(
 
     this.externalUri = Require.nonNull("Remote node URI", uri);
     this.gridUri = Require.nonNull("Grid URI", gridUri);
+    this.gridUrlSpecified = gridUrlSpecified;
     this.maxSessionCount =
         Math.min(Require.positive("Max session count", maxSessionCount), factories.size());
     this.heartbeatPeriod = heartbeatPeriod;
@@ -1221,10 +1224,12 @@ private Session createExternalSession(
     Capabilities toUse =
         ImmutableCapabilities.copyOf(requestCapabilities.merge(other.getCapabilities()));
 
+    URI baseUri = resolvePublicGridUri(toUse);
+
     // Add se:cdp if necessary to send the cdp url back
     if ((isSupportingCdp || toUse.getCapability("se:cdp") != null) && cdpEnabled) {
       String cdpPath = String.format("/session/%s/se/cdp", other.getId());
-      toUse = new PersistentCapabilities(toUse).setCapability("se:cdp", rewrite(cdpPath));
+      toUse = new PersistentCapabilities(toUse).setCapability("se:cdp", rewrite(cdpPath, baseUri));
     } else {
       // Remove any se:cdp* from the response, CDP is not supported nor enabled
       MutableCapabilities cdpFiltered = new MutableCapabilities();
@@ -1259,7 +1264,7 @@ private Session createExternalSession(
       toUse =
           new PersistentCapabilities(toUse)
               .setCapability("se:gridWebSocketUrl", uri)
-              .setCapability("webSocketUrl", rewrite(bidiPath));
+              .setCapability("webSocketUrl", rewrite(bidiPath, baseUri));
     } else {
       // Remove any "webSocketUrl" from the response, BiDi is not supported nor enabled
       MutableCapabilities bidiFiltered = new MutableCapabilities();
@@ -1278,23 +1283,43 @@ private Session createExternalSession(
     boolean isVncEnabled = toUse.getCapability("se:vncLocalAddress") != null;
     if (isVncEnabled) {
       String vncPath = String.format("/session/%s/se/vnc", other.getId());
-      toUse = new PersistentCapabilities(toUse).setCapability("se:vnc", rewrite(vncPath));
+      toUse = new PersistentCapabilities(toUse).setCapability("se:vnc", rewrite(vncPath, baseUri));
     }
 
     return new Session(other.getId(), externalUri, other.getStereotype(), toUse, Instant.now());
   }
 
-  private URI rewrite(String path) {
+  private URI rewrite(String path, URI baseUri) {
     try {
-      String scheme = "https".equals(gridUri.getScheme()) ? "wss" : "ws";
-      path = NodeOptions.normalizeSubPath(gridUri.getPath()) + path;
+      String scheme = "https".equals(baseUri.getScheme()) ? "wss" : "ws";
+      path = NodeOptions.normalizeSubPath(baseUri.getPath()) + path;
       return new URI(
-          scheme, gridUri.getUserInfo(), gridUri.getHost(), gridUri.getPort(), path, null, null);
+          scheme, baseUri.getUserInfo(), baseUri.getHost(), baseUri.getPort(), path, null, null);
     } catch (URISyntaxException e) {
       throw new RuntimeException(e);
     }
   }
 
+  // A configured grid-url always wins; only when the node falls back to its auto-detected address
+  // (which may be unreachable behind Docker/proxy) do we use the client-advertised se:remoteUrl.
+  private URI resolvePublicGridUri(Capabilities caps) {
+    if (gridUrlSpecified) {
+      return gridUri;
+    }
+    Object raw = caps.getCapability("se:remoteUrl");
+    if (raw instanceof String && !((String) raw).isEmpty()) {
+      try {
+        URI uri = new URI((String) raw);
+        if (uri.getHost() != null) {
+          return uri;
+        }
+      } catch (URISyntaxException e) {
+        // Fall back to gridUri.
+      }
+    }
+    return gridUri;
+  }
+
   @Override
   public NodeStatus getStatus() {
     Set<Slot> slots =
@@ -1457,6 +1482,7 @@ public static class Builder {
     private final Secret registrationSecret;
     private final List<SessionSlot> factories;
     private final List<NodeCommandInterceptor> interceptors = new ArrayList<>();
+    private boolean gridUrlSpecified = false;
     private int maxSessions = NodeOptions.DEFAULT_MAX_SESSIONS;
     private int drainAfterSessionCount = NodeOptions.DEFAULT_DRAIN_AFTER_SESSION_COUNT;
     private boolean cdpEnabled = NodeOptions.DEFAULT_ENABLE_CDP;
@@ -1548,12 +1574,18 @@ public Builder addInterceptor(NodeCommandInterceptor interceptor) {
       return this;
     }
 
+    public Builder gridUrlSpecified(boolean configured) {
+      this.gridUrlSpecified = configured;
+      return this;
+    }
+
     public LocalNode build() {
       return new LocalNode(
           tracer,
           bus,
           uri,
           gridUri,
+          gridUrlSpecified,
           healthCheck,
           maxSessions,
           drainAfterSessionCount,

java/src/org/openqa/selenium/grid/node/local/LocalNodeFactory.java

@@ -70,6 +70,7 @@ public static Node create(Config config) {
                 serverOptions.getExternalUri(),
                 nodeOptions.getPublicGridUri().orElseGet(serverOptions::getExternalUri),
                 secretOptions.getRegistrationSecret())
+            .gridUrlSpecified(nodeOptions.getPublicGridUri().isPresent())
             .maximumConcurrentSessions(nodeOptions.getMaxSessions())
             .sessionTimeout(sessionTimeout)
             .drainAfterSessionCount(nodeOptions.getDrainAfterSessionCount())

java/src/org/openqa/selenium/remote/RemoteWebDriver.java

@@ -260,9 +260,20 @@ protected void setSessionId(String opaqueKey) {
     sessionId = new SessionId(opaqueKey);
   }
 
+  private Capabilities addRemoteUrl(Capabilities capabilities) {
+    URI baseUri = clientConfig.baseUri();
+    if (baseUri == null) {
+      return capabilities;
+    }
+    MutableCapabilities withRemoteUrl = new MutableCapabilities(capabilities);
+    withRemoteUrl.setCapability("se:remoteUrl", baseUri.toString());
+    return withRemoteUrl;
+  }
+
   protected void startSession(Capabilities capabilities) {
     checkNonW3CCapabilities(capabilities);
     checkChromeW3CFalse(capabilities);
+    capabilities = addRemoteUrl(capabilities);
 
     try {
       Response response = execute(DriverCommand.NEW_SESSION(singleton(capabilities)));

java/src/org/openqa/selenium/remote/RemoteWebDriverBuilder.java

@@ -529,8 +529,14 @@ private Set<String> getClobberedCapabilities() {
   private NewSessionPayload getPayload() {
     Map<String, Object> roughPayload = new TreeMap<>(metadata);
 
+    Map<String, Object> alwaysMatch = new TreeMap<>(additionalCapabilities);
+    URI baseUri = getBaseUri();
+    if (baseUri != null) {
+      alwaysMatch.put("se:remoteUrl", baseUri.toString());
+    }
+
     Map<String, Object> w3cCaps = new TreeMap<>();
-    w3cCaps.put("alwaysMatch", additionalCapabilities);
+    w3cCaps.put("alwaysMatch", alwaysMatch);
     if (!requestedCapabilities.isEmpty()) {
       w3cCaps.put("firstMatch", requestedCapabilities);
     }

java/test/org/openqa/selenium/grid/node/NodeTest.java

@@ -209,6 +209,177 @@ void shouldCreateASessionIfTheCorrectCapabilitiesArePassedToIt() {
     assertThat(sessionResponse.getSession()).isNotNull();
   }
 
+  @Test
+  void usesClientReachableAddressForProxiedUrlsWhenRemoteUrlProvided() {
+    Capabilities request =
+        new ImmutableCapabilities(
+            "browserName",
+            "cheese",
+            "se:vncLocalAddress",
+            "localhost:5900",
+            "se:remoteUrl",
+            "http://localhost:9999");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        local.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://localhost:9999/session/" + session.getId() + "/se/vnc");
+  }
+
+  @Test
+  void preservesCredentialsFromClientAdvertisedRemoteUrl() {
+    Capabilities request =
+        new ImmutableCapabilities(
+            "browserName",
+            "cheese",
+            "se:vncLocalAddress",
+            "localhost:5900",
+            "se:remoteUrl",
+            "http://user:secret@localhost:9999");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        local.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://user:secret@localhost:9999/session/" + session.getId() + "/se/vnc");
+  }
+
+  @Test
+  void ignoresRemoteUrlWhenPublicGridUrlIsConfigured() throws URISyntaxException {
+    URI configuredGridUri = new URI("http://grid.example:4444");
+
+    class Handler extends Session implements HttpHandler {
+      private Handler(Capabilities capabilities) {
+        super(new SessionId(UUID.randomUUID()), uri, stereotype, capabilities, Instant.now());
+      }
+
+      @Override
+      public HttpResponse execute(HttpRequest req) throws UncheckedIOException {
+        return new HttpResponse();
+      }
+    }
+
+    LocalNode node =
+        LocalNode.builder(tracer, bus, uri, configuredGridUri, registrationSecret)
+            .gridUrlSpecified(true)
+            .add(caps, new TestSessionFactory((id, c) -> new Handler(c)))
+            .build();
+
+    Capabilities request =
+        new ImmutableCapabilities(
+            "browserName",
+            "cheese",
+            "se:vncLocalAddress",
+            "localhost:5900",
+            "se:remoteUrl",
+            "http://localhost:9999");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        node.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://grid.example:4444/session/" + session.getId() + "/se/vnc");
+  }
+
+  @Test
+  void preservesCredentialsFromConfiguredPublicGridUrl() throws URISyntaxException {
+    URI configuredGridUri = new URI("http://user:secret@grid.example:4444");
+
+    class Handler extends Session implements HttpHandler {
+      private Handler(Capabilities capabilities) {
+        super(new SessionId(UUID.randomUUID()), uri, stereotype, capabilities, Instant.now());
+      }
+
+      @Override
+      public HttpResponse execute(HttpRequest req) throws UncheckedIOException {
+        return new HttpResponse();
+      }
+    }
+
+    LocalNode node =
+        LocalNode.builder(tracer, bus, uri, configuredGridUri, registrationSecret)
+            .gridUrlSpecified(true)
+            .add(caps, new TestSessionFactory((id, c) -> new Handler(c)))
+            .build();
+
+    Capabilities request =
+        new ImmutableCapabilities(
+            "browserName",
+            "cheese",
+            "se:vncLocalAddress",
+            "localhost:5900",
+            "se:remoteUrl",
+            "http://localhost:9999");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        node.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://user:secret@grid.example:4444/session/" + session.getId() + "/se/vnc");
+  }
+
+  @Test
+  void ignoresRemoteUrlWhenGridUrlIsConfiguredEvenIfItEqualsNodeAddress() {
+    // Edge case: grid-url is explicitly configured to the same value as the node's own externalUri.
+    // The explicit configuration must still win over a client-advertised se:remoteUrl.
+    class Handler extends Session implements HttpHandler {
+      private Handler(Capabilities capabilities) {
+        super(new SessionId(UUID.randomUUID()), uri, stereotype, capabilities, Instant.now());
+      }
+
+      @Override
+      public HttpResponse execute(HttpRequest req) throws UncheckedIOException {
+        return new HttpResponse();
+      }
+    }
+
+    LocalNode node =
+        LocalNode.builder(tracer, bus, uri, uri, registrationSecret)
+            .gridUrlSpecified(true)
+            .add(caps, new TestSessionFactory((id, c) -> new Handler(c)))
+            .build();
+
+    Capabilities request =
+        new ImmutableCapabilities(
+            "browserName",
+            "cheese",
+            "se:vncLocalAddress",
+            "localhost:5900",
+            "se:remoteUrl",
+            "http://localhost:9999");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        node.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://localhost:1234/session/" + session.getId() + "/se/vnc");
+  }
+
+  @Test
+  void fallsBackToGridAddressForProxiedUrlsWithoutRemoteUrl() {
+    Capabilities request =
+        new ImmutableCapabilities("browserName", "cheese", "se:vncLocalAddress", "localhost:5900");
+
+    Either<WebDriverException, CreateSessionResponse> response =
+        local.newSession(createSessionRequest(request));
+    assertThatEither(response).isRight();
+
+    Session session = response.right().getSession();
+    assertThat(String.valueOf(session.getCapabilities().getCapability("se:vnc")))
+        .isEqualTo("ws://localhost:1234/session/" + session.getId() + "/se/vnc");
+  }
+
   @Test
   void shouldRetryIfNoMatchingSlotIsAvailable() {
     Node local =

java/test/org/openqa/selenium/remote/RemoteWebDriverBuilderTest.java

@@ -179,6 +179,24 @@ void shouldAllowMetaDataToBeSet() {
     assertThat(seen).isTrue();
   }
 
+  @Test
+  void advertisesRemoteUrlToTheServer() {
+    AtomicReference<Object> seen = new AtomicReference<>();
+
+    RemoteWebDriver.builder()
+        .oneOf(new FirefoxOptions())
+        .address("http://localhost:34576")
+        .connectingWith(
+            config ->
+                req -> {
+                  seen.set(listCapabilities(req).get(0).getCapability("se:remoteUrl"));
+                  return CANNED_SESSION_RESPONSE;
+                })
+        .build();
+
+    assertThat(seen.get()).isEqualTo("http://localhost:34576");
+  }
+
   @Test
   void doesNotAllowFirstMatchToBeUsedAsAMetadataNameAsItIsConfusing() {
     RemoteWebDriverBuilder builder = RemoteWebDriver.builder();