refactor: reuse the central HTTP client for self-update requests

Instead of the updater constructing its own reqwest client, hand it Git-Tool's
central one. `update::manager` now takes `&Core` and passes
`core.http_client().reqwest_client()` to update-rs, so self-update requests share
Git-Tool's client configuration and connection pool.

To make that possible the central `TrueHttpClient` now owns a single reqwest
client (built once, with a default `Git-Tool/<version>` User-Agent) rather than
creating one per request, and the `HttpClient` trait exposes it via
`reqwest_client()`. Call sites that set a per-request User-Agent (the GitHub
registry/service) still override the default, so their behaviour is unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: notheotherben

src/commands/open.rs

@@ -131,8 +131,8 @@ New applications can be configured either by making changes to your configuratio
 }
 
 impl OpenCommand {
-    #[tracing::instrument(err, skip(self, _core))]
-    async fn check_for_update(&self, _core: &Core) -> Result<Option<Release>, human_errors::Error> {
+    #[tracing::instrument(err, skip(self, core))]
+    async fn check_for_update(&self, core: &Core) -> Result<Option<Release>, human_errors::Error> {
         let current_version: semver::Version = version!().parse().map_err(|err| human_errors::wrap_system(
                 err,
                 "Could not parse the current application version into a SemVer version number.",
@@ -141,7 +141,7 @@ impl OpenCommand {
 
         info!("Current application version is v{}", current_version);
 
-        let releases = crate::update::manager().get_releases().await?;
+        let releases = crate::update::manager(core).get_releases().await?;
 
         let target_release = Release::get_latest(releases.iter().filter(|&r| {
             r.get_variant().is_some() && r.version > current_version && !r.prerelease

src/commands/update.rs

@@ -36,7 +36,7 @@ impl CommandRunnable for UpdateCommand {
 
     #[tracing::instrument(name = "gt update", err, skip(self, core, matches))]
     async fn run(&self, core: &Core, matches: &ArgMatches) -> Result<i32, engine::Error> {
-        let manager = crate::update::manager();
+        let manager = crate::update::manager(core);
 
         // When the updater relaunches us between phases it invokes
         // `gt update --state <json>`; hand that straight back to the updater to
@@ -125,10 +125,10 @@ impl CommandRunnable for UpdateCommand {
 
     #[tracing::instrument(
         name = "gt complete -- gt update",
-        skip(self, _core, completer, _matches)
+        skip(self, core, completer, _matches)
     )]
-    async fn complete(&self, _core: &Core, completer: &Completer, _matches: &ArgMatches) {
-        if let Ok(releases) = crate::update::manager().get_releases().await {
+    async fn complete(&self, core: &Core, completer: &Completer, _matches: &ArgMatches) {
+        if let Ok(releases) = crate::update::manager(core).get_releases().await {
             completer.offer_many(
                 releases
                     .iter()

src/engine/http.rs

@@ -20,13 +20,34 @@ pub trait HttpClient: Send + Sync {
     }
 
     async fn request(&self, req: Request) -> Result<Response, human_errors::Error>;
+
+    /// The underlying [`reqwest::Client`], for code that needs a real client
+    /// rather than this trait — e.g. the self-updater, which hands a
+    /// `reqwest::Client` to `update-rs`. It shares this client's configuration
+    /// and connection pool.
+    fn reqwest_client(&self) -> Client;
 }
 
 pub fn client() -> Arc<dyn HttpClient + Send + Sync> {
-    Arc::new(TrueHttpClient {})
+    Arc::new(TrueHttpClient {
+        client: build_client(),
+    })
+}
+
+/// Build Git-Tool's shared reqwest client, carrying a default `User-Agent` so
+/// requests that don't set their own are still attributed to Git-Tool (GitHub
+/// requires one). Call sites that set a per-request `User-Agent` still override
+/// it.
+fn build_client() -> Client {
+    Client::builder()
+        .user_agent(version!("Git-Tool/"))
+        .build()
+        .unwrap_or_else(|_| Client::new())
 }
 
-struct TrueHttpClient {}
+struct TrueHttpClient {
+    client: Client,
+}
 
 impl std::fmt::Debug for dyn HttpClient {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -58,9 +79,7 @@ impl HttpClient for TrueHttpClient {
         )
     )]
     async fn request(&self, req: Request) -> Result<Response, human_errors::Error> {
-        let client = Client::new();
-
-        let response = client.execute(req).await.to_human_error()?;
+        let response = self.client.execute(req).await.to_human_error()?;
 
         if !response.status().is_success() {
             Span::current().record("otel.status_code", 2_u32).record(
@@ -78,11 +97,17 @@ impl HttpClient for TrueHttpClient {
 
         Ok(response)
     }
+
+    fn reqwest_client(&self) -> Client {
+        self.client.clone()
+    }
 }
 
 impl From<Arc<Config>> for TrueHttpClient {
     fn from(_: Arc<Config>) -> Self {
-        Self {}
+        Self {
+            client: build_client(),
+        }
     }
 }
 

src/update.rs

@@ -8,6 +8,7 @@
 
 pub use update_rs::Release;
 
+use crate::engine::Core;
 use std::ffi::OsString;
 use update_rs::{GitHubSource, Launcher, UpdateManager, naming};
 
@@ -29,27 +30,18 @@ impl Launcher for GitToolLauncher {
     }
 }
 
-/// Build the HTTP client the updater uses, carrying Git-Tool's `User-Agent` (as
-/// GitHub requires) so self-update requests are attributed to Git-Tool rather
-/// than to update-rs's generic default client.
-fn http_client() -> reqwest::Client {
-    reqwest::Client::builder()
-        .user_agent(version!("Git-Tool/"))
-        .build()
-        .unwrap_or_else(|_| reqwest::Client::new())
-}
-
 /// Build an [`UpdateManager`] configured for Git-Tool's releases.
 ///
 /// It downloads the Go-style `git-tool-<os>-<arch>[.exe]` asset for the current
 /// platform (matching the names produced by `.github/workflows/release.yml`)
-/// from the project's GitHub releases, whose tags are `vX.Y.Z`, using Git-Tool's
-/// own HTTP client, and relaunches through the `update --state` sub-command.
-pub fn manager() -> UpdateManager<GitHubSource> {
+/// from the project's GitHub releases, whose tags are `vX.Y.Z`, reusing
+/// Git-Tool's shared HTTP client (from `core`), and relaunches through the
+/// `update --state` sub-command.
+pub fn manager(core: &Core) -> UpdateManager<GitHubSource> {
     UpdateManager::new(
         GitHubSource::new(REPO, naming::go("git-tool"))
             .with_release_tag_prefix("v")
-            .with_client(http_client()),
+            .with_client(core.http_client().reqwest_client()),
     )
     .with_launcher(Box::new(GitToolLauncher))
 }