update

backend/app/main.py

@@ -359,9 +359,156 @@ def _is_unipile_nonsense_display_name(val: str, account_id_hint: str = "") -> bo
         return True
     if account_id_hint and s == account_id_hint.strip():
         return True
+    if _looks_like_email(s):
+        return True
     return False
 
 
+def _looks_like_email(val: str) -> bool:
+    s = (val or "").strip()
+    if not s or "@" not in s:
+        return False
+    return bool(re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", s))
+
+
+def _display_name_from_email_local(email: str) -> str:
+    """Best-effort human label when UniPile only exposes the mailbox address (e.g. maya@co.com → Maya)."""
+    e = (email or "").strip()
+    if "@" not in e:
+        return ""
+    local = e.split("@", 1)[0].strip()
+    if not local:
+        return ""
+    parts = [p for p in re.split(r"[._+\-]+", local) if p and re.search(r"[A-Za-z]", p)]
+    if not parts:
+        return ""
+    return " ".join(p[:1].upper() + p[1:].lower() if len(p) > 1 else p.upper() for p in parts)
+
+
+def _mailbox_email_from_unipile_meta(meta: Any) -> str:
+    if not isinstance(meta, dict):
+        return ""
+    for layer in (meta.get("account_profile"), meta):
+        if not isinstance(layer, dict):
+            continue
+        cp = layer.get("connection_params")
+        if isinstance(cp, dict):
+            mail = cp.get("mail")
+            if isinstance(mail, dict):
+                for key in ("username", "imap_user", "smtp_user", "email"):
+                    v = _safe_str(mail.get(key))
+                    if _looks_like_email(v):
+                        return v
+        for key in ("email", "username"):
+            v = _safe_str(layer.get(key))
+            if _looks_like_email(v):
+                return v
+        n = _safe_str(layer.get("name"))
+        if _looks_like_email(n):
+            return n
+    return ""
+
+
+def _name_from_mailbox_label(label: str) -> str:
+    lab = (label or "").strip()
+    suffix = "'s mailbox"
+    if lab.endswith(suffix) and len(lab) > len(suffix):
+        cand = lab[: -len(suffix)].strip()
+        if cand and not _looks_like_email(cand) and not _is_unipile_nonsense_display_name(cand):
+            return cand
+    return ""
+
+
+def _try_fetch_mailbox_sender_display_name(account_id: str, mailbox_email: str = "") -> str:
+    """
+    Gmail 'Send mail as' display name often appears on sent messages as from_attendee.display_name.
+    UniPile account `name` is frequently the mailbox address only.
+    """
+    if not (account_id or "").strip():
+        return ""
+    acc_enc = requests.utils.quote(account_id.strip(), safe="")
+    want = (mailbox_email or "").strip().lower()
+    folder_candidates = ("SENT", "sent", "Sent", "Sent Items", "INBOX")
+    for folder in folder_candidates:
+        folder_enc = requests.utils.quote(folder, safe="")
+        st, data = _unipile_call(
+            "GET",
+            f"/api/v1/emails?account_id={acc_enc}&limit=15&folder={folder_enc}",
+        )
+        if st >= 400 or not isinstance(data, dict):
+            continue
+        items = data.get("items") or data.get("emails") or data.get("data") or []
+        if not isinstance(items, list):
+            continue
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            fa = item.get("from_attendee") or item.get("from") or {}
+            if not isinstance(fa, dict):
+                continue
+            dn = _safe_str(fa.get("display_name") or fa.get("name"))
+            ident = _safe_str(fa.get("identifier") or fa.get("email") or fa.get("address"))
+            if not dn or _looks_like_email(dn):
+                continue
+            if want and ident and ident.lower() != want:
+                continue
+            return dn
+    return ""
+
+
+def _resolve_mailbox_sender_name(
+    meta: Any,
+    *,
+    unipile_account_id: str = "",
+    label: str = "",
+    fetch_sent: bool = True,
+) -> str:
+    """Human sender name for mailbox UI + email sign-offs — never the raw mailbox address when avoidable."""
+    mailbox_email = _mailbox_email_from_unipile_meta(meta)
+    name = _extract_unipile_identity(meta if isinstance(meta, dict) else {})[0].strip()
+    if name and not _looks_like_email(name):
+        return name
+    if fetch_sent and unipile_account_id:
+        from_sent = _try_fetch_mailbox_sender_display_name(unipile_account_id, mailbox_email)
+        if from_sent:
+            return from_sent
+    from_label = _name_from_mailbox_label(label)
+    if from_label:
+        return from_label
+    if mailbox_email:
+        derived = _display_name_from_email_local(mailbox_email)
+        if derived:
+            return derived
+    return ""
+
+
+def _sanitize_sender_signoff_name(val: str) -> str:
+    s = (val or "").strip()
+    if not s or _looks_like_email(s):
+        return ""
+    return s
+
+
+def _mailbox_sender_name_for_user(db: Session, user_row: Optional[User]) -> str:
+    if not user_row:
+        return ""
+    pref = _sanitize_sender_signoff_name(getattr(user_row, "mailbox_profile_display_name", None) or "")
+    if pref:
+        return pref
+    ref_id = getattr(user_row, "default_mailbox_unipile_account_ref_id", None)
+    if ref_id is not None:
+        row = db.query(UnipileAccount).filter(UnipileAccount.id == int(ref_id)).first()
+        if row:
+            resolved = _resolve_mailbox_sender_name(
+                row.metadata_json or {},
+                unipile_account_id=row.unipile_account_id or "",
+                label=row.label or "",
+            )
+            if resolved:
+                return resolved
+    return _sanitize_sender_signoff_name(user_row.name or "")
+
+
 def _extract_unipile_identity_from_layer(data: dict, account_id_hint: str = "") -> tuple[str, str]:
     """Read display name + avatar from one object (e.g. GET /accounts/{id} payload)."""
     candidates_name = [
@@ -430,13 +577,47 @@ _MAILBOX_PROVIDER_SET = ("GOOGLE", "MICROSOFT", "OUTLOOK", "MAIL", "IMAP")
 
 
 def _mailbox_account_display_name(row: UnipileAccount) -> str:
-    meta = row.metadata_json if isinstance(row.metadata_json, dict) else {}
-    n = _extract_unipile_identity(meta)[0].strip()
+    n = _resolve_mailbox_sender_name(
+        row.metadata_json if isinstance(row.metadata_json, dict) else {},
+        unipile_account_id=row.unipile_account_id or "",
+        label=row.label or "",
+    )
     if n:
         return n
     return (row.label or "").strip() or "Mailbox"
 
 
+def _refresh_mailbox_account_identity(
+    db: Session,
+    row: UnipileAccount,
+    user_row: Optional[User],
+    *,
+    update_user_pref: bool = False,
+) -> None:
+    """Re-fetch UniPile profile / sent-mail display name when stored metadata only has the email address."""
+    account_id = row.unipile_account_id or ""
+    if not account_id:
+        return
+    profile = _try_fetch_unipile_account_profile(account_id)
+    meta = dict(row.metadata_json) if isinstance(row.metadata_json, dict) else {}
+    if isinstance(profile, dict) and profile:
+        meta["account_profile"] = profile
+    resolved = _resolve_mailbox_sender_name(
+        meta,
+        unipile_account_id=account_id,
+        label=row.label or "",
+        fetch_sent=True,
+    )
+    row.metadata_json = meta
+    if resolved:
+        row.label = f"{resolved}'s mailbox"[:255]
+        row.updated_at = datetime.utcnow()
+        if update_user_pref and user_row is not None:
+            cur = _sanitize_sender_signoff_name(getattr(user_row, "mailbox_profile_display_name", None) or "")
+            if not cur:
+                user_row.mailbox_profile_display_name = resolved[:200]
+
+
 def _try_fetch_unipile_account_profile(account_id: str) -> dict:
     """
     Optional enrichment call. If it fails, we just keep existing metadata.
@@ -1316,6 +1497,8 @@ async def patch_me_linkedin_prefs(
 async def unipile_mailbox_campaign_defaults(t: TenantContext = Depends(get_tenant_context)):
     db = t.db
     user_row = db.query(User).filter(User.id == t.user_id).first()
+    if user_row is not None and _looks_like_email(getattr(user_row, "mailbox_profile_display_name", None) or ""):
+        user_row.mailbox_profile_display_name = None
     rows = (
         db.query(UnipileAccount)
         .filter(
@@ -1326,6 +1509,32 @@ async def unipile_mailbox_campaign_defaults(t: TenantContext = Depends(get_tenan
         .order_by(UnipileAccount.created_at.desc(), UnipileAccount.id.desc())
         .all()
     )
+    default_ref = getattr(user_row, "default_mailbox_unipile_account_ref_id", None) if user_row else None
+    identity_dirty = False
+    for r in rows:
+        meta = r.metadata_json if isinstance(r.metadata_json, dict) else {}
+        raw_identity = _extract_unipile_identity(meta)[0]
+        resolved_quick = _resolve_mailbox_sender_name(
+            meta,
+            unipile_account_id=r.unipile_account_id or "",
+            label=r.label or "",
+            fetch_sent=False,
+        )
+        if r.unipile_account_id and (_looks_like_email(raw_identity) or not resolved_quick):
+            _refresh_mailbox_account_identity(
+                db,
+                r,
+                user_row,
+                update_user_pref=(
+                    default_ref is not None and int(default_ref) == int(r.id)
+                    or (default_ref is None and rows and int(r.id) == int(rows[0].id))
+                ),
+            )
+            identity_dirty = True
+    if identity_dirty:
+        db.commit()
+        if user_row is not None:
+            db.refresh(user_row)
     accounts = []
     for r in rows:
         ident = _extract_unipile_identity(r.metadata_json or {})
@@ -1342,7 +1551,11 @@ async def unipile_mailbox_campaign_defaults(t: TenantContext = Depends(get_tenan
                 "created_at": r.created_at.isoformat() if r.created_at else None,
             }
         )
-    prof = (getattr(user_row, "mailbox_profile_display_name", None) or "").strip() if user_row else ""
+    prof = _sanitize_sender_signoff_name(
+        (getattr(user_row, "mailbox_profile_display_name", None) or "").strip() if user_row else ""
+    )
+    if not prof and user_row:
+        prof = _mailbox_sender_name_for_user(db, user_row)
     default_ref = getattr(user_row, "default_mailbox_unipile_account_ref_id", None) if user_row else None
     valid_default = None
     if default_ref is not None and any(a["id"] == default_ref for a in accounts):
@@ -1365,7 +1578,7 @@ async def patch_me_mailbox_prefs(
         raise HTTPException(status_code=404, detail="User not found")
     patch = body.model_dump(exclude_unset=True)
     if "mailbox_profile_display_name" in patch:
-        s = (patch["mailbox_profile_display_name"] or "").strip()
+        s = _sanitize_sender_signoff_name((patch["mailbox_profile_display_name"] or "").strip())
         u.mailbox_profile_display_name = s[:200] if s else None
     if "default_mailbox_unipile_account_ref_id" in patch:
         rid = patch["default_mailbox_unipile_account_ref_id"]
@@ -1406,7 +1619,7 @@ async def create_unipile_mailbox_hosted_link(
     expires_at = datetime.utcnow() + timedelta(minutes=20)
     u = t.db.query(User).filter(User.id == t.user_id).first()
     if u is not None and body.mailbox_profile_display_name is not None:
-        s = (body.mailbox_profile_display_name or "").strip()
+        s = _sanitize_sender_signoff_name((body.mailbox_profile_display_name or "").strip())
         if s:
             u.mailbox_profile_display_name = s[:200]
     state = UnipileHostedAuthState(
@@ -1482,9 +1695,16 @@ async def unipile_mailbox_hosted_callback(request: Request, db: Session = Depend
         .first()
     )
     user_row = db.query(User).filter(User.id == state.user_id).first()
-    box_name = _extract_unipile_identity(merged_meta)[0].strip()
+    box_name = _resolve_mailbox_sender_name(
+        merged_meta,
+        unipile_account_id=unipile_account_id,
+        label=(state.label or "").strip(),
+        fetch_sent=True,
+    )
     if user_row is not None and box_name:
         user_row.mailbox_profile_display_name = box_name[:200]
+    elif user_row is not None and _looks_like_email(getattr(user_row, "mailbox_profile_display_name", None) or ""):
+        user_row.mailbox_profile_display_name = None
     nice_label = (state.label or "").strip() or "Mailbox"
     if box_name:
         nice_label = f"{box_name}'s mailbox"
@@ -1520,8 +1740,10 @@ async def unipile_mailbox_hosted_callback(request: Request, db: Session = Depend
 
 @app.get("/api/unipile/mailbox/accounts")
 async def list_unipile_mailbox_accounts(t: TenantContext = Depends(get_tenant_context)):
+    db = t.db
+    user_row = db.query(User).filter(User.id == t.user_id).first()
     rows = (
-        t.db.query(UnipileAccount)
+        db.query(UnipileAccount)
         .filter(
             UnipileAccount.tenant_id == t.tenant_id,
             UnipileAccount.user_id == t.user_id,
@@ -1530,6 +1752,15 @@ async def list_unipile_mailbox_accounts(t: TenantContext = Depends(get_tenant_co
         .order_by(UnipileAccount.created_at.desc(), UnipileAccount.id.desc())
         .all()
     )
+    identity_dirty = False
+    for r in rows:
+        meta = r.metadata_json if isinstance(r.metadata_json, dict) else {}
+        raw_identity = _extract_unipile_identity(meta)[0]
+        if r.unipile_account_id and _looks_like_email(raw_identity):
+            _refresh_mailbox_account_identity(db, r, user_row, update_user_pref=False)
+            identity_dirty = True
+    if identity_dirty:
+        db.commit()
     out = []
     for r in rows:
         ident = _extract_unipile_identity(r.metadata_json or {})
@@ -3924,16 +4155,14 @@ async def generate_sequences(
                 db.commit()
 
             user_row = db.query(User).filter(User.id == t.user_id).first()
-            mailbox_sig = ""
+            mailbox_sig = _mailbox_sender_name_for_user(db, user_row)
             linkedin_sig = ""
             if user_row:
-                mailbox_sig = (
-                    (getattr(user_row, "mailbox_profile_display_name", None) or "").strip()
-                    or (user_row.name or "").strip()
-                )
                 linkedin_sig = (
-                    (getattr(user_row, "linkedin_profile_display_name", None) or "").strip()
-                    or (user_row.name or "").strip()
+                    _sanitize_sender_signoff_name(
+                        (getattr(user_row, "linkedin_profile_display_name", None) or "").strip()
+                    )
+                    or _sanitize_sender_signoff_name((user_row.name or "").strip())
                 )
 
             total_contacts = len(df)