Address review: inline cache, detect scheduler context, trim README

- Inline the cache read/write in getSenderAddresses instead of the
  readCache/writeCache helpers. Drop the try/catch around them: a cache
  failure now fails sender detection entirely rather than silently
  degrading.
- Detect the scheduler context explicitly so a task run manually from the
  scheduler backend module also uses the longer timeout (not just cron).
  CLI is detected via PHP_SAPI, the browser case via the request's
  "module" attribute (identifier "scheduler"). This also removes the
  Environment::isCli() guard that only existed for the test harness.
- Remove the cache note from the README (implementation detail).

Author: claude

Classes/Import/Provider/BrevoSenderProvider.php

@@ -6,10 +6,11 @@
 
 use Hn\MailSender\Import\SenderAddressSourceProviderInterface;
 use Hn\MailSender\Import\ValueObject\SenderAddress;
+use Psr\Http\Message\ServerRequestInterface;
 use Psr\Log\LoggerInterface;
+use TYPO3\CMS\Backend\Module\ModuleInterface;
 use TYPO3\CMS\Core\Cache\CacheManager;
 use TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
-use TYPO3\CMS\Core\Core\Environment;
 use TYPO3\CMS\Core\Http\RequestFactory;
 
 /**
@@ -73,8 +74,9 @@ public function getSenderAddresses(): array
         // Include the key in the cache identifier so switching keys (e.g. a
         // different Brevo account) never serves senders from the previous one.
         $cacheIdentifier = 'brevo_senders_' . sha1($apiKey);
+        $cache = $this->cacheManager->getCache(self::CACHE_IDENTIFIER);
 
-        $cached = $this->readCache($cacheIdentifier);
+        $cached = $cache->get($cacheIdentifier);
         if (is_array($cached)) {
             return $this->mapToSenderAddresses($cached);
         }
@@ -83,7 +85,7 @@ public function getSenderAddresses(): array
 
         // Cache even an empty result so a misconfigured key or transient outage
         // does not trigger a fresh API call on every backend page view.
-        $this->writeCache($cacheIdentifier, $senders);
+        $cache->set($cacheIdentifier, $senders, [], self::CACHE_LIFETIME);
 
         return $this->mapToSenderAddresses($senders);
     }
@@ -103,32 +105,6 @@ private function getApiKey(): string
         }
     }
 
-    /**
-     * @return array<int, array{email: string, name: string}>|null Cached senders, or null on miss/error
-     */
-    private function readCache(string $identifier): ?array
-    {
-        try {
-            $value = $this->cacheManager->getCache(self::CACHE_IDENTIFIER)->get($identifier);
-            return is_array($value) ? $value : null;
-        } catch (\Throwable) {
-            // Cache unavailable (not registered, backend error, ...): treat as a miss.
-            return null;
-        }
-    }
-
-    /**
-     * @param array<int, array{email: string, name: string}> $senders
-     */
-    private function writeCache(string $identifier, array $senders): void
-    {
-        try {
-            $this->cacheManager->getCache(self::CACHE_IDENTIFIER)->set($identifier, $senders, [], self::CACHE_LIFETIME);
-        } catch (\Throwable) {
-            // Caching is best-effort: never let a cache failure break sender import.
-        }
-    }
-
     /**
      * Fetch active senders from the Brevo API.
      *
@@ -186,22 +162,32 @@ private function fetchActiveSenders(string $apiKey): array
     }
 
     /**
-     * Use a shorter timeout in interactive contexts (e.g. the backend module) and a
-     * longer one in non-interactive ones (scheduler/CLI cron), where completeness
-     * matters more than latency.
-     *
-     * Environment::isCli() is the idiomatic check and is always initialized at TYPO3
-     * runtime; it is guarded so a non-initialized environment can never break the import.
+     * Use a shorter timeout in the interactive backend module, where a user waits
+     * for the page to render, and a longer one when sender detection runs from the
+     * scheduler.
      */
     private function getRequestTimeout(): int
     {
-        try {
-            $isCli = Environment::isCli();
-        } catch (\Throwable) {
-            $isCli = PHP_SAPI === 'cli';
+        return $this->isSchedulerContext() ? self::TIMEOUT_BACKGROUND : self::TIMEOUT_INTERACTIVE;
+    }
+
+    /**
+     * Whether sender detection is currently triggered by the scheduler, either via
+     * cron (CLI) or run manually from the scheduler backend module. Running a task
+     * from the browser must not shorten the timeout.
+     */
+    private function isSchedulerContext(): bool
+    {
+        // Cron: `typo3 scheduler:run`.
+        if (PHP_SAPI === 'cli') {
+            return true;
         }
 
-        return $isCli ? self::TIMEOUT_BACKGROUND : self::TIMEOUT_INTERACTIVE;
+        // Manual execution via the scheduler backend module.
+        $request = $GLOBALS['TYPO3_REQUEST'] ?? null;
+        $module = $request instanceof ServerRequestInterface ? $request->getAttribute('module') : null;
+
+        return $module instanceof ModuleInterface && $module->getIdentifier() === 'scheduler';
     }
 
     /**

README.md

@@ -126,9 +126,6 @@ Notes:
 - Only **active** Brevo senders are imported. The import is additive: senders
   that are later deactivated or removed in Brevo are **not** automatically
   disabled or deleted locally.
-- The API response is cached for 60 seconds (in the *system* cache group), which
-  also rate-limits the API. Flushing the system caches forces an immediate
-  refresh.
 
 > **More providers welcome.** The importer is built around a simple provider
 > interface (`SenderAddressSourceProviderInterface`). If you use another email