Add send-timeout API and honor commandPowerOn timeout

Addresses upstream review on the httplib timeout PR:

  - Add setSendTimeout / getConfiguredSendTimeout to the base class
    (DashboardClientImpl), mirroring the existing read-timeout API.
    getConfiguredSendTimeout has a non-pure default that returns the
    documented 1 s value, so DashboardClientImplG5 needs no change.
  - Override both in DashboardClientImplX with a send_timeout_ member
    parallel to recv_timeout_. The setter updates the underlying
    httplib::Client; the getter falls back to the 10 s constructor
    default until a caller configures it explicitly.
  - Bump the constructor's read/write timeouts from 1 s / 5 s to
    10 s / 10 s. The 1 s read default was too tight for legitimate
    blocking calls (brake_release, commandLoadProgram, program
    upload/update/download). The 10 s figure covers all non-power-on
    commands without per-method timeouts; callers can override via
    setReceiveTimeout / setSendTimeout.
  - Honor the timeout parameter on commandPowerOn using the same
    save-bump-restore pattern as connect(): cache the configured
    read timeout, set it to the caller-supplied value for the PUT,
    restore on both success and exception (catch(...) rethrow).

Author: Vinicius-T-Robotics

include/ur_client_library/ur/dashboard_client_implementation.h

@@ -135,6 +135,27 @@ class DashboardClientImpl
    */
   virtual void setReceiveTimeout([[maybe_unused]] const timeval& timeout) {};
 
+  /*!
+   * \brief Gets the configured send timeout. If send timeout is unconfigured "normal" socket
+   * timeout of 1 second will be returned.
+   *
+   * \returns configured send timeout
+   */
+  virtual timeval getConfiguredSendTimeout() const
+  {
+    timeval tv;
+    tv.tv_sec = 1;
+    tv.tv_usec = 0;
+    return tv;
+  }
+
+  /*!
+   * \brief Sets the send timeout for the socket.
+   *
+   * \param timeout The timeout to be set
+   */
+  virtual void setSendTimeout([[maybe_unused]] const timeval& timeout) {};
+
   /*!
    * \brief Sends command and verifies that a valid answer is received.
    *

include/ur_client_library/ur/dashboard_client_implementation_x.h

@@ -164,6 +164,8 @@ class DashboardClientImplX : public DashboardClientImpl
 
   // Defined in the .cpp because httplib::Client is only forward-declared in this header.
   void setReceiveTimeout(const timeval& timeout) override;
+  void setSendTimeout(const timeval& timeout) override;
+  timeval getConfiguredSendTimeout() const override;
 
 protected:
   DashboardResponse performProgramUpload(
@@ -184,10 +186,11 @@ class DashboardClientImplX : public DashboardClientImpl
 
   std::unique_ptr<httplib::Client> cli_;
   VersionInformation robot_api_version_;
-  // Caller-configured read timeout. Null until setReceiveTimeout() is called explicitly;
-  // getConfiguredReceiveTimeout() returns the documented 1 s default in that case. Mirrors
-  // the recv_timeout_ pattern used by DashboardClientImplG5.
+  // Caller-configured timeouts. Null until the corresponding setter is called explicitly;
+  // the getters fall back to the constructor default (10 s) in that case. Mirrors the
+  // recv_timeout_ pattern used by DashboardClientImplG5.
   std::unique_ptr<timeval> recv_timeout_;
+  std::unique_ptr<timeval> send_timeout_;
 };
 
 }  // namespace urcl

src/ur/dashboard_client_implementation_x.cpp

@@ -53,11 +53,16 @@ DashboardClientImplX::DashboardClientImplX(const std::string& host) : DashboardC
 
   // cpp-httplib's default read_timeout is 300 seconds. Applied unchanged, this makes any
   // dashboard call hang for 5 minutes when the controller becomes unresponsive (e.g. network
-  // partition, paused container in tests). Align with the contract documented on the base
-  // class: getConfiguredReceiveTimeout() returns {tv_sec = 1, tv_usec = 0} on this impl.
+  // partition, paused container in tests).
+  //
+  // The 10 s default for read/write is chosen to cover blocking calls that legitimately take
+  // time on real hardware — brake_release, commandLoadProgram (read), commandUploadProgram
+  // (write), commandUpdateProgram (write), commandDownloadProgram (read) — without forcing
+  // each one to plumb its own timeout. commandPowerOn already accepts its own (longer)
+  // timeout parameter. Callers needing different limits can override via setReceiveTimeout.
   cli_->set_connection_timeout(std::chrono::seconds(5));
-  cli_->set_read_timeout(std::chrono::seconds(1));
-  cli_->set_write_timeout(std::chrono::seconds(5));
+  cli_->set_read_timeout(std::chrono::seconds(10));
+  cli_->set_write_timeout(std::chrono::seconds(10));
 }
 
 void DashboardClientImplX::setReceiveTimeout(const timeval& timeout)
@@ -69,6 +74,15 @@ void DashboardClientImplX::setReceiveTimeout(const timeval& timeout)
   }
 }
 
+void DashboardClientImplX::setSendTimeout(const timeval& timeout)
+{
+  send_timeout_ = std::make_unique<timeval>(timeout);
+  if (cli_)
+  {
+    cli_->set_write_timeout(std::chrono::seconds(timeout.tv_sec) + std::chrono::microseconds(timeout.tv_usec));
+  }
+}
+
 std::string DashboardClientImplX::sendAndReceive([[maybe_unused]] const std::string& text)
 {
   throw NotImplementedException("sendAndReceive is not implemented for DashboardClientImplX.");
@@ -134,15 +148,33 @@ void DashboardClientImplX::disconnect()
 timeval DashboardClientImplX::getConfiguredReceiveTimeout() const
 {
   // If the caller has explicitly configured a receive timeout via setReceiveTimeout,
-  // return that. Otherwise fall back to the documented 1 s default. Mirrors G5.
+  // return that. Otherwise fall back to the constructor default. See the constructor
+  // comment for the rationale on the 10 s default (covers brake_release / program
+  // load/upload/download without per-method timeouts).
   timeval tv;
   if (recv_timeout_ != nullptr)
   {
     tv = *recv_timeout_;
   }
   else
   {
-    tv.tv_sec = 1;
+    tv.tv_sec = 10;
+    tv.tv_usec = 0;
+  }
+  return tv;
+}
+
+timeval DashboardClientImplX::getConfiguredSendTimeout() const
+{
+  // Mirrors getConfiguredReceiveTimeout. Default of 10 s matches the constructor.
+  timeval tv;
+  if (send_timeout_ != nullptr)
+  {
+    tv = *send_timeout_;
+  }
+  else
+  {
+    tv.tv_sec = 10;
     tv.tv_usec = 0;
   }
   return tv;
@@ -196,9 +228,32 @@ DashboardResponse DashboardClientImplX::commandPowerOff()
   return put("/robotstate/v1/state", R"({"action": "POWER_OFF"})");
 }
 
-DashboardResponse DashboardClientImplX::commandPowerOn([[maybe_unused]] const std::chrono::duration<double> timeout)
+DashboardResponse DashboardClientImplX::commandPowerOn(const std::chrono::duration<double> timeout)
 {
-  return put("/robotstate/v1/state", R"({"action": "POWER_ON"})");
+  // commandPowerOn can take significantly longer than steady-state dashboard calls (the robot
+  // boots, runs self-checks, etc.). Bump the read timeout to the caller-supplied value for the
+  // duration of the PUT, then restore — using the same save-bump-restore pattern as connect().
+  // The restore must run on every exit, including exceptions from inside put(), hence the
+  // catch(...) rethrow guard.
+  timeval configured_tv = getConfiguredReceiveTimeout();
+  timeval pwron_tv;
+  pwron_tv.tv_sec = static_cast<time_t>(std::chrono::duration_cast<std::chrono::seconds>(timeout).count());
+  pwron_tv.tv_usec = 0;
+  setReceiveTimeout(pwron_tv);
+
+  DashboardResponse response;
+  try
+  {
+    response = put("/robotstate/v1/state", R"({"action": "POWER_ON"})");
+  }
+  catch (...)
+  {
+    setReceiveTimeout(configured_tv);
+    throw;
+  }
+
+  setReceiveTimeout(configured_tv);
+  return response;
 }
 
 DashboardResponse DashboardClientImplX::commandBrakeRelease()