Phase 5: PSR-18 HTTP client support

- Add psr/http-client + psr/http-factory to require (interface packages only)
- Remove constructor from HttpClientInterface — it blocked DI for adapters
- Add Psr18Adapter implementing HttpClientInterface; factories are optional
  when the PSR-18 client also implements them (e.g. Symfony Psr18Client)
- Add CoyoteCert::httpClient() builder method; wired through to Api for
  both issue() and ARI renewal checks

Author: bashgeek

composer.json

@@ -8,6 +8,8 @@
     "ext-json": "*",
     "ext-mbstring": "*",
     "ext-openssl": "*",
+    "psr/http-client": "^1.0",
+    "psr/http-factory": "^1.0",
     "psr/log": "^3.0",
     "spatie/dns": "^2.7"
   },

src/CoyoteCert.php

@@ -8,7 +8,9 @@
 use CoyoteCert\Enums\KeyType;
 use CoyoteCert\DTO\RenewalWindow;
 use CoyoteCert\Exceptions\LetsEncryptClientException;
+use CoyoteCert\Http\Psr18Adapter;
 use CoyoteCert\Interfaces\ChallengeHandlerInterface;
+use CoyoteCert\Interfaces\HttpClientInterface;
 use CoyoteCert\Provider\AcmeProviderInterface;
 use CoyoteCert\Storage\StoredCertificate;
 use CoyoteCert\Storage\StorageInterface;
@@ -37,6 +39,7 @@ class CoyoteCert
 {
     private ?StorageInterface          $storage          = null;
     private ?LoggerInterface           $logger           = null;
+    private ?HttpClientInterface       $httpClient       = null;
     private string                     $email            = '';
     private string                     $profile          = '';
     private array                      $domains          = [];
@@ -88,6 +91,22 @@ public function logger(LoggerInterface $logger): self
         return $this;
     }
 
+    /**
+     * Use a PSR-18 HTTP client instead of the built-in curl client.
+     *
+     * $requestFactory and $streamFactory are optional when the PSR-18 client
+     * also implements those interfaces (e.g. Symfony's Psr18Client).
+     */
+    public function httpClient(
+        \Psr\Http\Client\ClientInterface $client,
+        ?\Psr\Http\Message\RequestFactoryInterface $requestFactory = null,
+        ?\Psr\Http\Message\StreamFactoryInterface $streamFactory = null,
+    ): self {
+        $this->httpClient = new Psr18Adapter($client, $requestFactory, $streamFactory);
+
+        return $this;
+    }
+
     /** @param string|string[] $domains */
     public function domains(array|string $domains): self
     {
@@ -173,6 +192,7 @@ public function issue(): StoredCertificate
             provider:       $this->provider,
             storage:        $this->storage,
             logger:         $this->logger,
+            httpClient:     $this->httpClient,
             accountKeyType: $this->accountKeyType,
         );
 
@@ -297,7 +317,7 @@ private function ariWindow(StoredCertificate $cert): ?RenewalWindow
         }
 
         try {
-            return (new Api(provider: $this->provider, logger: $this->logger))
+            return (new Api(provider: $this->provider, logger: $this->logger, httpClient: $this->httpClient))
                 ->renewalInfo()
                 ->get($cert->certificate, $m[1]);
         } catch (\Throwable) {

src/Http/Psr18Adapter.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace CoyoteCert\Http;
+
+use Psr\Http\Client\ClientInterface;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use CoyoteCert\Interfaces\HttpClientInterface;
+
+/**
+ * Adapts any PSR-18 HTTP client to CoyoteCert's internal HttpClientInterface.
+ *
+ * Both $requestFactory and $streamFactory are optional when the PSR-18 client
+ * also implements those interfaces (e.g. Symfony's Psr18Client, nyholm/psr7).
+ *
+ * Usage:
+ *
+ *   // Symfony — client implements all three interfaces
+ *   CoyoteCert::with(new LetsEncrypt())
+ *       ->httpClient(new \Symfony\Component\HttpClient\Psr18Client())
+ *       ->issue();
+ *
+ *   // Guzzle — separate factory required
+ *   CoyoteCert::with(new LetsEncrypt())
+ *       ->httpClient(new \GuzzleHttp\Client(), new \GuzzleHttp\Psr7\HttpFactory())
+ *       ->issue();
+ */
+class Psr18Adapter implements HttpClientInterface
+{
+    private RequestFactoryInterface $requestFactory;
+    private StreamFactoryInterface $streamFactory;
+
+    public function __construct(
+        private readonly ClientInterface $client,
+        ?RequestFactoryInterface $requestFactory = null,
+        ?StreamFactoryInterface $streamFactory = null,
+    ) {
+        $this->requestFactory = $requestFactory
+            ?? ($client instanceof RequestFactoryInterface ? $client
+                : throw new \InvalidArgumentException(
+                    'Provide a RequestFactoryInterface or use a client that implements it (e.g. Symfony Psr18Client).'
+                ));
+
+        $this->streamFactory = $streamFactory
+            ?? ($client instanceof StreamFactoryInterface ? $client
+                : throw new \InvalidArgumentException(
+                    'Provide a StreamFactoryInterface or use a client that implements it (e.g. Symfony Psr18Client).'
+                ));
+    }
+
+    public function head(string $url): Response
+    {
+        $request = $this->requestFactory->createRequest('HEAD', $url)
+            ->withHeader('User-Agent', 'blendbyte/coyote-cert')
+            ->withHeader('Accept', 'application/json');
+
+        return $this->send($request, $url);
+    }
+
+    public function get(string $url, array $headers = [], array $arguments = [], int $maxRedirects = 0): Response
+    {
+        if (!empty($arguments)) {
+            $url .= '?' . http_build_query($arguments);
+        }
+
+        $request = $this->requestFactory->createRequest('GET', $url)
+            ->withHeader('User-Agent', 'blendbyte/coyote-cert')
+            ->withHeader('Accept', 'application/json');
+
+        foreach ($headers as $header) {
+            [$name, $value] = explode(':', $header, 2);
+            $request = $request->withAddedHeader(trim($name), trim($value));
+        }
+
+        return $this->send($request, $url);
+    }
+
+    public function post(string $url, array $payload = [], array $headers = [], int $maxRedirects = 0): Response
+    {
+        $body    = json_encode($payload, JSON_THROW_ON_ERROR);
+        $request = $this->requestFactory->createRequest('POST', $url)
+            ->withHeader('User-Agent', 'blendbyte/coyote-cert')
+            ->withHeader('Accept', 'application/json')
+            ->withHeader('Content-Type', 'application/jose+json')
+            ->withBody($this->streamFactory->createStream($body));
+
+        foreach ($headers as $header) {
+            [$name, $value] = explode(':', $header, 2);
+            $request = $request->withAddedHeader(trim($name), trim($value));
+        }
+
+        return $this->send($request, $url);
+    }
+
+    private function send(\Psr\Http\Message\RequestInterface $request, string $url): Response
+    {
+        $psrResponse = $this->client->sendRequest($request);
+
+        $headers = [];
+        foreach ($psrResponse->getHeaders() as $name => $values) {
+            $headers[strtolower($name)] = implode(', ', $values);
+        }
+
+        $rawBody = (string) $psrResponse->getBody();
+        $body    = json_validate($rawBody)
+            ? json_decode($rawBody, true, 512, JSON_THROW_ON_ERROR)
+            : $rawBody;
+
+        return new Response(
+            headers:      $headers,
+            requestedUrl: $url,
+            statusCode:   $psrResponse->getStatusCode(),
+            body:         $body,
+        );
+    }
+}

src/Interfaces/HttpClientInterface.php

@@ -6,8 +6,6 @@
 
 interface HttpClientInterface
 {
-    public function __construct(int $timeout = 10);
-
     public function head(string $url): Response;
 
     public function get(string $url, array $headers = [], array $arguments = [], int $maxRedirects = 0): Response;