update

backend/app/auth_routes.py

@@ -254,9 +254,13 @@ async def auth_me(request: Request, db: Session = Depends(get_db)):
 
     lpdn = None
     duar = None
+    mpdn = None
+    dmuar = None
     if urow:
         lpdn = getattr(urow, "linkedin_profile_display_name", None)
         duar = getattr(urow, "default_unipile_account_ref_id", None)
+        mpdn = getattr(urow, "mailbox_profile_display_name", None)
+        dmuar = getattr(urow, "default_mailbox_unipile_account_ref_id", None)
 
     return {
         **profile,
@@ -267,6 +271,8 @@ async def auth_me(request: Request, db: Session = Depends(get_db)):
         "gmail_invites_ready": gmail_invites_ready,
         "linkedin_profile_display_name": lpdn or "",
         "default_unipile_account_ref_id": int(duar) if duar is not None else None,
+        "mailbox_profile_display_name": mpdn or "",
+        "default_mailbox_unipile_account_ref_id": int(dmuar) if dmuar is not None else None,
     }
 
 

backend/app/database.py

@@ -37,6 +37,8 @@ class User(Base):
     google_refresh_token = Column(Text, nullable=True)  # for Gmail send (invite emails); treat as secret
     linkedin_profile_display_name = Column(String, nullable=True)
     default_unipile_account_ref_id = Column(Integer, ForeignKey("unipile_accounts.id"), nullable=True)
+    mailbox_profile_display_name = Column(String, nullable=True)
+    default_mailbox_unipile_account_ref_id = Column(Integer, ForeignKey("unipile_accounts.id"), nullable=True)
     created_at = Column(DateTime, default=datetime.utcnow)
 
 
@@ -335,6 +337,10 @@ def run_migrations(connection_engine):
                 conn.execute(text("ALTER TABLE users ADD COLUMN linkedin_profile_display_name TEXT"))
             if "default_unipile_account_ref_id" not in ucols:
                 conn.execute(text("ALTER TABLE users ADD COLUMN default_unipile_account_ref_id INTEGER"))
+            if "mailbox_profile_display_name" not in ucols:
+                conn.execute(text("ALTER TABLE users ADD COLUMN mailbox_profile_display_name TEXT"))
+            if "default_mailbox_unipile_account_ref_id" not in ucols:
+                conn.execute(text("ALTER TABLE users ADD COLUMN default_mailbox_unipile_account_ref_id INTEGER"))
 
         insp = inspect(connection_engine)
         if insp.has_table("crm_deals"):

backend/app/main.py

@@ -57,7 +57,9 @@ from .models import (
     WonBillingPayload,
     UnipileConnectRequest,
     UnipileHostedLinkRequest,
+    UnipileMailboxHostedLinkRequest,
     UserLinkedinPrefsPatch,
+    UserMailboxPrefsPatch,
     LinkedinCampaignCreateRequest,
     LinkedinCampaignGenerateRequest,
     LinkedinCampaignExecuteRequest,
@@ -392,6 +394,17 @@ def _linkedin_account_display_name(row: UnipileAccount) -> str:
     return lab or "LinkedIn account"
 
 
+_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()
+    if n:
+        return n
+    return (row.label or "").strip() or "Mailbox"
+
+
 def _try_fetch_unipile_account_profile(account_id: str) -> dict:
     """
     Optional enrichment call. If it fails, we just keep existing metadata.
@@ -1267,6 +1280,242 @@ async def patch_me_linkedin_prefs(
     }
 
 
+@app.get("/api/unipile/mailbox/campaign-defaults")
+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()
+    rows = (
+        db.query(UnipileAccount)
+        .filter(
+            UnipileAccount.tenant_id == t.tenant_id,
+            UnipileAccount.user_id == t.user_id,
+            UnipileAccount.provider.in_(_MAILBOX_PROVIDER_SET),
+        )
+        .order_by(UnipileAccount.created_at.desc(), UnipileAccount.id.desc())
+        .all()
+    )
+    accounts = []
+    for r in rows:
+        ident = _extract_unipile_identity(r.metadata_json or {})
+        accounts.append(
+            {
+                "id": r.id,
+                "label": r.label or "Mailbox",
+                "display_name": _mailbox_account_display_name(r),
+                "avatar_url": ident[1] or "",
+                "provider": r.provider,
+                "unipile_account_id": r.unipile_account_id,
+                "status": r.status or "unknown",
+                "auth_mode": r.auth_mode or "hosted",
+                "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 ""
+    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):
+        valid_default = default_ref
+    return {
+        "mailbox_profile_display_name": prof,
+        "default_mailbox_unipile_account_ref_id": valid_default,
+        "accounts": accounts,
+    }
+
+
+@app.patch("/api/me/mailbox-prefs")
+async def patch_me_mailbox_prefs(
+    body: UserMailboxPrefsPatch,
+    t: TenantContext = Depends(get_tenant_context),
+):
+    db = t.db
+    u = db.query(User).filter(User.id == t.user_id).first()
+    if not u:
+        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()
+        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"]
+        if rid is None or rid == 0:
+            u.default_mailbox_unipile_account_ref_id = None
+        else:
+            acc = (
+                db.query(UnipileAccount)
+                .filter(
+                    UnipileAccount.id == rid,
+                    UnipileAccount.tenant_id == t.tenant_id,
+                    UnipileAccount.user_id == t.user_id,
+                    UnipileAccount.provider.in_(_MAILBOX_PROVIDER_SET),
+                )
+                .first()
+            )
+            if not acc:
+                raise HTTPException(status_code=404, detail="Mailbox account not found for this user")
+            u.default_mailbox_unipile_account_ref_id = rid
+    db.commit()
+    return {
+        "ok": True,
+        "mailbox_profile_display_name": (u.mailbox_profile_display_name or ""),
+        "default_mailbox_unipile_account_ref_id": u.default_mailbox_unipile_account_ref_id,
+    }
+
+
+@app.post("/api/unipile/mailbox/hosted-link")
+async def create_unipile_mailbox_hosted_link(
+    body: UnipileMailboxHostedLinkRequest,
+    request: Request,
+    t: TenantContext = Depends(get_tenant_context),
+):
+    origin = (FRONTEND_ORIGIN or "").strip().rstrip("/") or _public_origin_from_request(request)
+    if not origin:
+        raise HTTPException(status_code=400, detail="Could not determine frontend origin for hosted auth.")
+    token = str(uuid.uuid4())
+    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()
+        if s:
+            u.mailbox_profile_display_name = s[:200]
+    state = UnipileHostedAuthState(
+        tenant_id=t.tenant_id,
+        user_id=t.user_id,
+        token=token,
+        provider="GOOGLE",
+        label=(body.label or "Mailbox").strip(),
+        expires_at=expires_at,
+    )
+    t.db.add(state)
+    t.db.commit()
+    expires_iso = expires_at.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    payload = {
+        "type": "create",
+        "providers": ["GOOGLE"],
+        "api_url": UNIPILE_API_BASE,
+        "expiresOn": expires_iso,
+        "notify_url": f"{origin}/api/unipile/mailbox/hosted-callback",
+        "success_redirect_url": f"{origin}/settings?mailbox=connected",
+        "failure_redirect_url": f"{origin}/settings?mailbox=failed",
+        "name": token,
+    }
+    response = _unipile_request("POST", "/api/v1/hosted/accounts/link", payload)
+    hosted_url = _safe_str(response.get("url") if isinstance(response, dict) else "")
+    if not hosted_url:
+        raise HTTPException(status_code=400, detail="UniPile did not return hosted auth URL")
+    return {"url": hosted_url}
+
+
+@app.post("/api/unipile/mailbox/hosted-callback")
+async def unipile_mailbox_hosted_callback(request: Request, db: Session = Depends(get_db)):
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Expected JSON body")
+    name_token = _safe_str((body or {}).get("name"))
+    unipile_account_id = _safe_str((body or {}).get("account_id"))
+    status = _safe_str((body or {}).get("status") or "connected")
+    if not name_token:
+        raise HTTPException(status_code=400, detail="Missing name token")
+    if not unipile_account_id:
+        return {"ok": True, "ignored": True, "reason": "missing_account_id"}
+    account_profile = _try_fetch_unipile_account_profile(unipile_account_id)
+    merged_meta = {}
+    if isinstance(body, dict):
+        merged_meta.update(body)
+    if isinstance(account_profile, dict) and account_profile:
+        merged_meta["account_profile"] = account_profile
+    state = (
+        db.query(UnipileHostedAuthState)
+        .filter(
+            UnipileHostedAuthState.token == name_token,
+            UnipileHostedAuthState.provider == "GOOGLE",
+        )
+        .first()
+    )
+    if not state:
+        return {"ok": True, "ignored": True, "reason": "unknown_token"}
+    if state.used_at is not None:
+        return {"ok": True, "ignored": True, "reason": "token_already_used"}
+    if state.expires_at and state.expires_at < datetime.utcnow():
+        return {"ok": True, "ignored": True, "reason": "token_expired"}
+    existing = (
+        db.query(UnipileAccount)
+        .filter(
+            UnipileAccount.tenant_id == state.tenant_id,
+            UnipileAccount.user_id == state.user_id,
+            UnipileAccount.provider.in_(_MAILBOX_PROVIDER_SET),
+            UnipileAccount.unipile_account_id == unipile_account_id,
+        )
+        .first()
+    )
+    user_row = db.query(User).filter(User.id == state.user_id).first()
+    box_name = _extract_unipile_identity(merged_meta)[0].strip()
+    if user_row is not None and box_name:
+        user_row.mailbox_profile_display_name = box_name[:200]
+    nice_label = (state.label or "").strip() or "Mailbox"
+    if box_name:
+        nice_label = f"{box_name}'s mailbox"
+    nice_label = nice_label[:255]
+    if existing:
+        existing.label = nice_label
+        existing.status = status or existing.status
+        existing.auth_mode = "hosted"
+        existing.metadata_json = merged_meta or body
+        existing.updated_at = datetime.utcnow()
+        if user_row is not None and getattr(user_row, "default_mailbox_unipile_account_ref_id", None) is None:
+            user_row.default_mailbox_unipile_account_ref_id = existing.id
+    else:
+        row = UnipileAccount(
+            tenant_id=state.tenant_id,
+            user_id=state.user_id,
+            label=nice_label,
+            provider="GOOGLE",
+            unipile_account_id=unipile_account_id,
+            status=status or "connected",
+            auth_mode="hosted",
+            metadata_json=merged_meta or body,
+        )
+        db.add(row)
+        db.flush()
+        acc_ref_id = row.id
+        if user_row is not None and getattr(user_row, "default_mailbox_unipile_account_ref_id", None) is None:
+            user_row.default_mailbox_unipile_account_ref_id = acc_ref_id
+    state.used_at = datetime.utcnow()
+    db.commit()
+    return {"ok": True}
+
+
+@app.get("/api/unipile/mailbox/accounts")
+async def list_unipile_mailbox_accounts(t: TenantContext = Depends(get_tenant_context)):
+    rows = (
+        t.db.query(UnipileAccount)
+        .filter(
+            UnipileAccount.tenant_id == t.tenant_id,
+            UnipileAccount.user_id == t.user_id,
+            UnipileAccount.provider.in_(_MAILBOX_PROVIDER_SET),
+        )
+        .order_by(UnipileAccount.created_at.desc(), UnipileAccount.id.desc())
+        .all()
+    )
+    out = []
+    for r in rows:
+        ident = _extract_unipile_identity(r.metadata_json or {})
+        out.append(
+            {
+                "id": r.id,
+                "label": r.label or "Mailbox",
+                "display_name": _mailbox_account_display_name(r),
+                "avatar_url": ident[1] or "",
+                "provider": r.provider,
+                "unipile_account_id": r.unipile_account_id,
+                "status": r.status or "unknown",
+                "auth_mode": r.auth_mode or "hosted",
+                "created_at": r.created_at.isoformat() if r.created_at else None,
+            }
+        )
+    return {"accounts": out}
+
+
 @app.get("/api/unipile/linkedin/accounts")
 async def list_unipile_linkedin_accounts(t: TenantContext = Depends(get_tenant_context)):
     rows = (

backend/app/models.py

@@ -250,12 +250,23 @@ class UnipileHostedLinkRequest(BaseModel):
     """User-facing name for campaigns (saved on your profile when starting hosted auth)."""
 
 
+class UnipileMailboxHostedLinkRequest(BaseModel):
+    label: str = "Mailbox"
+    mailbox_profile_display_name: Optional[str] = None
+
+
 class UserLinkedinPrefsPatch(BaseModel):
     linkedin_profile_display_name: Optional[str] = Field(None, max_length=200)
     default_unipile_account_ref_id: Optional[int] = Field(None, ge=0)
     """Use 0 to clear the default account selection."""
 
 
+class UserMailboxPrefsPatch(BaseModel):
+    mailbox_profile_display_name: Optional[str] = Field(None, max_length=200)
+    default_mailbox_unipile_account_ref_id: Optional[int] = Field(None, ge=0)
+    """Use 0 to clear the default mailbox account selection."""
+
+
 class LinkedinCampaignCreateRequest(BaseModel):
     name: str
     unipile_account_ref_id: int

frontend/src/components/settings/ConnectMailboxSettings.jsx

@@ -0,0 +1,168 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import { Mail, RefreshCw, Loader2 } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { apiFetch } from '@/lib/api';
+import { cn } from '@/lib/utils';
+
+export default function ConnectMailboxSettings() {
+    const [loading, setLoading] = useState(true);
+    const [busy, setBusy] = useState(false);
+    const [profileName, setProfileName] = useState('');
+    const [accountLabel, setAccountLabel] = useState('Mailbox');
+    const [accounts, setAccounts] = useState([]);
+    const [defaultRefId, setDefaultRefId] = useState(null);
+
+    const load = useCallback(async () => {
+        setLoading(true);
+        try {
+            const r = await apiFetch('/api/unipile/mailbox/campaign-defaults');
+            const d = r.ok ? await r.json() : {};
+            setProfileName(d.mailbox_profile_display_name || '');
+            setAccounts(d.accounts || []);
+            setDefaultRefId(d.default_mailbox_unipile_account_ref_id ?? null);
+            const n = (d.mailbox_profile_display_name || '').trim();
+            setAccountLabel(n ? `${n}'s mailbox` : 'Mailbox');
+        } catch {
+            setAccounts([]);
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        load();
+    }, [load]);
+
+    const savePreferences = async () => {
+        setBusy(true);
+        try {
+            const payload = { mailbox_profile_display_name: profileName.trim() };
+            if (defaultRefId != null) payload.default_mailbox_unipile_account_ref_id = defaultRefId;
+            const res = await apiFetch('/api/me/mailbox-prefs', {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) throw new Error(data.detail || 'Could not save');
+            setProfileName(data.mailbox_profile_display_name || '');
+            setDefaultRefId(data.default_mailbox_unipile_account_ref_id ?? null);
+            await load();
+        } catch (e) {
+            alert(e.message || 'Save failed');
+        } finally {
+            setBusy(false);
+        }
+    };
+
+    const connectAccount = async () => {
+        setBusy(true);
+        try {
+            const res = await apiFetch('/api/unipile/mailbox/hosted-link', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    label: accountLabel.trim() || 'Mailbox',
+                    mailbox_profile_display_name: profileName.trim() || undefined,
+                }),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) throw new Error(data.detail || 'Could not start mailbox connect');
+            if (data.url) window.location.href = data.url;
+        } catch (e) {
+            alert(e.message || 'Connect failed');
+        } finally {
+            setBusy(false);
+        }
+    };
+
+    return (
+        <section className="rounded-2xl border border-slate-200 bg-white p-6 shadow-sm">
+            <div className="flex flex-wrap items-start justify-between gap-3">
+                <div className="flex items-center gap-2 font-semibold text-slate-800">
+                    <Mail className="h-5 w-5 text-violet-600" />
+                    Connect Mailbox
+                </div>
+                <Button type="button" variant="outline" size="sm" disabled={loading || busy} onClick={load}>
+                    <RefreshCw className={cn('mr-2 h-4 w-4', loading && 'animate-spin')} />
+                    Refresh
+                </Button>
+            </div>
+
+            <div className="mt-4 grid gap-3 md:grid-cols-2">
+                <div>
+                    <label className="mb-1 block text-xs font-medium text-slate-600">Mailbox profile name</label>
+                    <Input
+                        placeholder="e.g. Seth S"
+                        value={profileName}
+                        onChange={(e) => setProfileName(e.target.value)}
+                        className="h-10"
+                    />
+                </div>
+                <div>
+                    <label className="mb-1 block text-xs font-medium text-slate-600">Account label</label>
+                    <Input
+                        placeholder="e.g. Seth S's mailbox"
+                        value={accountLabel}
+                        onChange={(e) => setAccountLabel(e.target.value)}
+                        className="h-10"
+                    />
+                </div>
+            </div>
+
+            <div className="mt-4 flex flex-wrap gap-2">
+                <Button type="button" disabled={busy} onClick={savePreferences} variant="outline">
+                    {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : 'Save preferences'}
+                </Button>
+                <Button type="button" disabled={busy} onClick={connectAccount} className="bg-slate-900 text-white">
+                    Connect mailbox
+                </Button>
+            </div>
+
+            {loading ? (
+                <div className="mt-6 flex justify-center py-8 text-slate-400">
+                    <Loader2 className="h-8 w-8 animate-spin" />
+                </div>
+            ) : accounts.length === 0 ? (
+                <p className="mt-6 text-sm text-slate-500">Connected mailboxes: 0</p>
+            ) : (
+                <div className="mt-6 space-y-3">
+                    <p className="text-sm font-medium text-slate-700">
+                        Connected mailboxes ({accounts.length}) — default for email sequence steps
+                    </p>
+                    <ul className="space-y-2">
+                        {accounts.map((a) => {
+                            const name = a.display_name || a.label || 'Mailbox';
+                            const checked = defaultRefId != null && Number(defaultRefId) === Number(a.id);
+                            return (
+                                <li
+                                    key={a.id}
+                                    className={cn(
+                                        'flex cursor-pointer items-center gap-3 rounded-xl border px-3 py-2 transition',
+                                        checked ? 'border-violet-300 bg-violet-50/60' : 'border-slate-200 hover:bg-slate-50'
+                                    )}
+                                    onClick={() => setDefaultRefId(a.id)}
+                                >
+                                    <input
+                                        type="radio"
+                                        className="h-4 w-4 accent-violet-600"
+                                        checked={checked}
+                                        onChange={() => setDefaultRefId(a.id)}
+                                    />
+                                    <div className="min-w-0 flex-1">
+                                        <p className="truncate font-medium text-slate-900">{name}</p>
+                                        <p className="truncate text-xs text-slate-500">{a.label}</p>
+                                    </div>
+                                    <span className="text-[10px] font-semibold uppercase text-slate-400">
+                                        {a.status || '—'}
+                                    </span>
+                                </li>
+                            );
+                        })}
+                    </ul>
+                </div>
+            )}
+        </section>
+    );
+}

frontend/src/pages/Settings.jsx

@@ -10,6 +10,7 @@ import {
 } from 'lucide-react';
 import AppShell from '@/components/layout/AppShell';
 import LinkedInConnectSettings from '@/components/settings/LinkedInConnectSettings';
+import ConnectMailboxSettings from '@/components/settings/ConnectMailboxSettings';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import {
@@ -190,8 +191,8 @@ export default function Settings() {
             title="Settings"
             subtitle={
                 isAdmin
-                    ? 'Invitations, members, Smartlead webhook, and LinkedIn.'
-                    : 'Smartlead webhook and LinkedIn. Invites and member management require admin.'
+                    ? 'Invitations, members, LinkedIn, mailbox, and Smartlead webhook.'
+                    : 'LinkedIn, mailbox, and Smartlead webhook. Invites and member management require admin.'
             }
         >
             <div className="space-y-8 max-w-3xl">
@@ -355,6 +356,9 @@ export default function Settings() {
                 </section>
                 ) : null}
 
+                <LinkedInConnectSettings />
+                <ConnectMailboxSettings />
+
                 <section className="rounded-2xl border border-slate-200 bg-white p-6 shadow-sm">
                     <div className="flex items-center gap-2 text-slate-800 font-semibold mb-4">
                         <Link2 className="h-5 w-5 text-violet-600" />
@@ -406,8 +410,6 @@ export default function Settings() {
                         </div>
                     ) : null}
                 </section>
-
-                <LinkedInConnectSettings />
             </div>
         </AppShell>
     );