fix: fetch() selects message body by structure, not length (v0.1.3)

select the literal payload by isinstance bytearray instead of len>20. aioimaplib
stores the message body as the only bytearray in the response; every other line
(including the '<id> FETCH (...' header) is plain bytes. the length heuristic
matched the header line first for any 2+ digit message id or BODY[]/UID fetch,
returning a blank Message and silently breaking OTP retrieval on real mailboxes.

Signed-off-by: disqualifier <dev@disqualifier.me>

README.md

@@ -11,16 +11,16 @@ This reads codes from email; it does not generate them (that is `pyotp`'s job).
 `requirements.txt`:
 
 ```
-aiomail @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.0
+aiomail @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.3
 # OAuth token providers (Microsoft / Google) need the extra:
-aiomail[oauth] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.0
+aiomail[oauth] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.3
 ```
 
 Direct:
 
 ```bash
-pip install "aiomail @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.0"
-pip install "aiomail[oauth] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.0"
+pip install "aiomail @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.3"
+pip install "aiomail[oauth] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiomail.git@v0.1.3"
 ```
 
 Requires `aioimaplib` and `beautifulsoup4` (pulled transitively). The `oauth`

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aiomail"
-version = "0.1.0"
+version = "0.1.3"
 description = "async IMAP one-time-code retrieval with password/OAuth2 auth and dynamic matching"
 requires-python = ">=3.10"
 dependencies = [

src/aiomail/__init__.py

@@ -29,4 +29,4 @@ __all__ = [
     "DEFAULT_FOLDERS",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.1.3"

src/aiomail/auth.py

@@ -38,6 +38,15 @@ class PasswordAuth:
             raise RuntimeError(f"login failed: {result} {data}")
 
 
+def _as_str(token) -> str:
+    """coerce a token to str (a provider may hand back bytes)
+
+    both XOAUTH2 entrypoints downstream need a str (one .encode()s it, the SASL
+    builder interpolates it), so normalize here rather than crashing on bytes.
+    """
+    return token.decode() if isinstance(token, bytes) else token
+
+
 def _sasl_xoauth2(user: str, token: str) -> str:
     """build the base64 XOAUTH2 SASL initial-response string"""
     raw = f"user={user}\x01auth=Bearer {token}\x01\x01".encode()
@@ -71,17 +80,19 @@ class OAuth2Auth:
             token = await result if hasattr(result, "__await__") else result
             if not token:
                 raise RuntimeError("token provider returned an empty token")
-            return token
-        return self._token  # type: ignore[return-value]
+            return _as_str(token)
+        return _as_str(self._token)  # type: ignore[arg-type]
 
     async def authenticate(self, mail) -> None:
         token = await self._resolve_token()
-        # aioimaplib exposes mail.xoauth2(user, token: bytes) — note the token must
-        # be bytes, not str. older/other clients that lack it but expose a generic
-        # authenticate() are driven via the SASL string from _sasl_xoauth2.
+        # aioimaplib's mail.xoauth2(user, token) builds the SASL string by f-string
+        # interpolating the token, so token MUST be str — passing bytes interpolates
+        # the b'...' repr and corrupts the Bearer value. _resolve_token already
+        # returns str (via _as_str). clients lacking .xoauth2 are driven via the
+        # SASL callback from _sasl_xoauth2.
         xoauth2 = getattr(mail, "xoauth2", None)
         if xoauth2 is not None:
-            result, data = await xoauth2(self.user, token.encode())
+            result, data = await xoauth2(self.user, token)
         elif hasattr(mail, "authenticate"):
             result, data = await mail.authenticate(
                 "XOAUTH2", lambda _: _sasl_xoauth2(self.user, token)

src/aiomail/client.py

@@ -67,7 +67,12 @@ class IMAPClient:
                 return True
             except Exception as exc:
                 log.warning("connect attempt %d/%d failed: %s", attempt + 1, self.max_retries, exc)
-                self._mail = None
+                if self._mail is not None:
+                    try:
+                        await self._mail.logout()
+                    except Exception as teardown:
+                        log.debug("logout error ignored during failed connect: %s", teardown)
+                    self._mail = None
                 await asyncio.sleep(2 * (attempt + 1))
         return False
 
@@ -138,7 +143,14 @@ class IMAPClient:
             return []
         if result != "OK" or not data or not data[0]:
             return []
-        ids = [int(x) for x in data[0].split()]
+        ids = []
+        for token in data[0].split():
+            try:
+                ids.append(int(token))
+            except (TypeError, ValueError):
+                # tolerate a malformed/non-numeric token in the SEARCH response
+                # instead of crashing the whole search
+                log.debug("skipping non-numeric search token: %r", token)
         return sorted(set(ids), reverse=True)
 
     async def fetch(self, email_id: int, *, icloud: bool = False) -> Optional[email.message.Message]:
@@ -157,7 +169,11 @@ class IMAPClient:
         if result != "OK" or not data:
             return None
         for item in data:
-            if isinstance(item, (bytes, bytearray)) and len(item) > 20:
+            # aioimaplib stores the literal message payload as the only bytearray in
+            # the response; every other line (including the `<id> FETCH (...` header)
+            # is plain bytes. select by structure, not length — a length heuristic
+            # mismatches the header line for any 2+ digit id or a BODY[]/UID fetch.
+            if isinstance(item, bytearray):
                 return email.message_from_bytes(bytes(item))
             if isinstance(item, tuple) and len(item) > 1:
                 return email.message_from_bytes(item[1])

src/aiomail/oauth.py

@@ -6,6 +6,7 @@ without aiohttp raises a clear error only when a provider is instantiated.
 
 credentials (client_id, refresh_token) are always supplied by the caller.
 """
+import asyncio
 import logging
 import time
 from typing import Optional, Sequence
@@ -85,8 +86,6 @@ class _RefreshTokenProvider:
                 except Exception as exc:
                     log.warning("token request to %s failed: %s", endpoint, exc)
             if attempt < self.max_retries - 1:
-                import asyncio
-
                 await asyncio.sleep(2 ** attempt)
 
         self._failures += 1

src/aiomail/retrieve.py

@@ -20,16 +20,18 @@ log = logging.getLogger(__name__)
 DEFAULT_FOLDERS: Sequence[str] = ("INBOX", "Junk", "Spam", "Archive", "All Mail")
 
 
-def _server_query(sender: MatchSpec, subject: MatchSpec) -> str:
+def _server_query(sender: MatchSpec, subject: MatchSpec, match_field: str = "from") -> str:
     """build a narrowing IMAP query from plain-string specs only
 
-    only plain strings translate to server-side FROM/SUBJECT filters; regex and
-    callable specs fall back to ALL and are filtered client-side, so dynamic
-    matching always works even when the server cannot express it.
+    only plain strings translate to server-side filters; regex and callable specs
+    fall back to ALL and are filtered client-side, so dynamic matching always works
+    even when the server cannot express it. `match_field` selects which header the
+    `sender` spec searches: "from" filters by the sender address (default), "to"
+    filters by the recipient address (the per-user alias the code was sent to).
     """
     parts: List[str] = []
     if isinstance(sender, str):
-        parts.append(f'FROM "{sender}"')
+        parts.append(f'TO "{sender}"' if match_field == "to" else f'FROM "{sender}"')
     if isinstance(subject, str):
         parts.append(f'SUBJECT "{subject}"')
     return f"({' '.join(parts)})" if parts else "ALL"
@@ -52,6 +54,7 @@ async def retrieve_otp(
     *,
     sender: MatchSpec = None,
     subject: MatchSpec = None,
+    match_field: str = "from",
     folders: Optional[Iterable[str]] = None,
     patterns: Sequence[Union[str, Pattern]] = DEFAULT_PATTERNS,
     lengths: Iterable[int] = DEFAULT_LENGTHS,
@@ -64,14 +67,18 @@ async def retrieve_otp(
 ) -> Optional[str]:
     """return the newest OTP matching the filters, or None
 
-    sender/subject accept a substring, a compiled regex, or a callable. folders,
-    patterns, code lengths, max age and retry behavior are all tunable. set
-    `max_age=None` to disable the freshness check.
+    sender/subject accept a substring, a compiled regex, or a callable. `match_field`
+    selects which header the `sender` spec is matched against: "from" (default)
+    matches the sender address; "to" matches the recipient address (the per-user
+    alias the code was sent to) and additionally accepts a forwarded match on the
+    From header, so a forwarded code still resolves. folders, patterns, code lengths,
+    max age and retry behavior are all tunable. set `max_age=None` to disable the
+    freshness check.
     """
     folders = list(folders) if folders is not None else list(DEFAULT_FOLDERS)
     sender_ok = as_predicate(sender)
     subject_ok = as_predicate(subject)
-    query = _server_query(sender, subject)
+    query = _server_query(sender, subject, match_field)
 
     for attempt in range(retries + 1):
         for folder in folders:
@@ -91,7 +98,12 @@ async def retrieve_otp(
 
                 from_hdr = message.get("From", "")
                 subj_hdr = message.get("Subject", "")
-                if not sender_ok(from_hdr) or not subject_ok(subj_hdr):
+                if match_field == "to":
+                    to_hdr = message.get("To", "")
+                    matched = sender_ok(to_hdr) or sender_ok(from_hdr)
+                else:
+                    matched = sender_ok(from_hdr)
+                if not matched or not subject_ok(subj_hdr):
                     continue
 
                 code = extract_code(message, patterns=patterns, lengths=lengths)