update

backend/app/main.py

@@ -18,6 +18,7 @@ import asyncio
 import math
 import re
 import requests
+from urllib.parse import urlparse, unquote
 from datetime import datetime, timedelta
 from calendar import monthrange
 
@@ -159,12 +160,53 @@ def _pick_linkedin_url(raw_data: Dict) -> str:
             "linkedin url",
             "linkedin profile",
             "person linkedin url",
+            "person linkedin profile url",
             "linkedin profile url",
+            "linkedin public url",
             "linkedin_url",
+            "linkedin profile link",
         ],
     )
 
 
+def _normalize_linkedin_url(raw: str) -> str:
+    """Strip whitespace; upgrade http→https for stable display and parsing."""
+    s = _safe_str(raw)
+    if not s:
+        return ""
+    if s.startswith("http://"):
+        s = "https://" + s[len("http://") :]
+    return s
+
+
+def _linkedin_public_identifier(raw: str) -> str:
+    """
+    UniPile profile lookup expects the public slug from /in/{slug}, not a full URL.
+    Accepts plain slugs (e.g. satyanadella) as well.
+    """
+    s = _normalize_linkedin_url(raw).strip()
+    if not s:
+        return ""
+    low = s.lower()
+    if "linkedin.com" in low:
+        try:
+            path = urlparse(s).path or ""
+        except Exception:
+            path = ""
+        path = unquote(path).strip("/")
+        parts = [p for p in path.split("/") if p]
+        for i, seg in enumerate(parts):
+            if seg.lower() == "in" and i + 1 < len(parts):
+                slug = parts[i + 1].strip()
+                return slug.split("?")[0].strip()
+            if seg.lower() == "sales" and i + 2 < len(parts) and parts[i + 1].lower() == "lead":
+                # /sales/lead/{slug}
+                return parts[i + 2].split("?")[0].strip()
+        return ""
+    # Already a slug / identifier (no URL)
+    return s.split("?")[0].strip("/").strip()
+
+
 def _require_unipile_config():
     if not UNIPILE_API_BASE or not UNIPILE_API_KEY:
         raise HTTPException(
@@ -181,7 +223,11 @@ def _unipile_headers():
     }
 
 
-def _unipile_request(method: str, path: str, payload: Optional[dict] = None):
+def _unipile_call(method: str, path: str, payload: Optional[dict] = None):
+    """
+    Raw UniPile HTTP call. Returns (status_code, parsed_body).
+    Raises HTTPException only on transport failure (not on 4xx/5xx responses).
+    """
     _require_unipile_config()
     url = f"{UNIPILE_API_BASE}{path}"
     try:
@@ -199,7 +245,12 @@ def _unipile_request(method: str, path: str, payload: Optional[dict] = None):
         data = resp.json()
     except Exception:
         data = {"raw": resp.text}
-    if resp.status_code >= 400:
+    return resp.status_code, data
+
+
+def _unipile_request(method: str, path: str, payload: Optional[dict] = None):
+    status, data = _unipile_call(method, path, payload)
+    if status >= 400:
         msg = None
         if isinstance(data, dict):
             msg = (
@@ -211,12 +262,20 @@ def _unipile_request(method: str, path: str, payload: Optional[dict] = None):
             if isinstance(msg, (dict, list)):
                 msg = json.dumps(msg)
         raise HTTPException(
-            status_code=resp.status_code,
-            detail=msg or f"UniPile error ({resp.status_code}): {resp.text}",
+            status_code=status,
+            detail=msg or f"UniPile error ({status}): {data if not isinstance(data, dict) else json.dumps(data)}",
         )
     return data
 
 
+def _linkedin_invite_note(text: str) -> str:
+    """LinkedIn personalized invite notes are short; keep a safe upper bound."""
+    t = _safe_str(text).replace("\r\n", "\n").strip()
+    if len(t) <= 280:
+        return t
+    return t[:277].rstrip() + "..."
+
+
 def _public_origin_from_request(request: Request) -> str:
     """
     Resolve browser-facing origin behind proxies (HF Spaces, ingress).
@@ -231,6 +290,45 @@ def _public_origin_from_request(request: Request) -> str:
     return str(request.base_url).rstrip("/")
 
 
+def _extract_unipile_identity(data: Optional[dict]) -> tuple[str, str]:
+    """
+    Best-effort extraction of profile display name and avatar URL from UniPile account payloads.
+    """
+    if not isinstance(data, dict):
+        return "", ""
+    candidates_name = [
+        data.get("name"),
+        data.get("display_name"),
+        data.get("full_name"),
+        (data.get("user") or {}).get("name") if isinstance(data.get("user"), dict) else None,
+        (data.get("profile") or {}).get("name") if isinstance(data.get("profile"), dict) else None,
+        (data.get("account") or {}).get("name") if isinstance(data.get("account"), dict) else None,
+    ]
+    candidates_avatar = [
+        data.get("picture"),
+        data.get("avatar"),
+        data.get("photo_url"),
+        data.get("image_url"),
+        (data.get("user") or {}).get("picture") if isinstance(data.get("user"), dict) else None,
+        (data.get("profile") or {}).get("picture") if isinstance(data.get("profile"), dict) else None,
+        (data.get("profile") or {}).get("avatar") if isinstance(data.get("profile"), dict) else None,
+    ]
+    name = next((_safe_str(x) for x in candidates_name if _safe_str(x)), "")
+    avatar = next((_safe_str(x) for x in candidates_avatar if _safe_str(x)), "")
+    return name, avatar
+
+
+def _try_fetch_unipile_account_profile(account_id: str) -> dict:
+    """
+    Optional enrichment call. If it fails, we just keep existing metadata.
+    """
+    try:
+        out = _unipile_request("GET", f"/api/v1/accounts/{requests.utils.quote(account_id, safe='')}")
+        return out if isinstance(out, dict) else {}
+    except Exception:
+        return {}
+
+
 def _contact_value(contact: Contact, field: str):
     if field == "first_name":
         return contact.first_name or _pick_from_raw(contact.raw_data, ["first name", "firstname", "first_name"])
@@ -1023,6 +1121,8 @@ async def list_unipile_linkedin_accounts(t: TenantContext = Depends(get_tenant_c
             {
                 "id": r.id,
                 "label": r.label or "LinkedIn account",
+                "display_name": _extract_unipile_identity(r.metadata_json or {})[0] or (r.label or "LinkedIn account"),
+                "avatar_url": _extract_unipile_identity(r.metadata_json or {})[1] or "",
                 "provider": r.provider,
                 "unipile_account_id": r.unipile_account_id,
                 "status": r.status or "unknown",
@@ -1092,6 +1192,12 @@ async def unipile_linkedin_hosted_callback(request: Request, db: Session = Depen
         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)
@@ -1122,7 +1228,7 @@ async def unipile_linkedin_hosted_callback(request: Request, db: Session = Depen
         existing.label = state.label or existing.label
         existing.status = status or existing.status
         existing.auth_mode = "hosted"
-        existing.metadata_json = body
+        existing.metadata_json = merged_meta or body
         existing.updated_at = datetime.utcnow()
     else:
         db.add(
@@ -1134,7 +1240,7 @@ async def unipile_linkedin_hosted_callback(request: Request, db: Session = Depen
                 unipile_account_id=unipile_account_id,
                 status=status or "connected",
                 auth_mode="hosted",
-                metadata_json=body,
+                metadata_json=merged_meta or body,
             )
         )
     state.used_at = datetime.utcnow()
@@ -1173,6 +1279,10 @@ async def connect_unipile_linkedin(
         account_id = _safe_str((response or {}).get("account", {}).get("id") if isinstance(response, dict) else "")
     if not account_id:
         raise HTTPException(status_code=400, detail="UniPile did not return an account_id")
+    account_profile = _try_fetch_unipile_account_profile(account_id)
+    merged_meta = response if isinstance(response, dict) else {"raw": str(response)}
+    if isinstance(merged_meta, dict) and account_profile:
+        merged_meta["account_profile"] = account_profile
 
     db_row = UnipileAccount(
         tenant_id=t.tenant_id,
@@ -1182,7 +1292,7 @@ async def connect_unipile_linkedin(
         unipile_account_id=account_id,
         status=_safe_str(response.get("status") if isinstance(response, dict) else "") or "connected",
         auth_mode=body.auth_mode,
-        metadata_json=response if isinstance(response, dict) else {"raw": str(response)},
+        metadata_json=merged_meta,
     )
     t.db.add(db_row)
     t.db.commit()
@@ -1227,6 +1337,7 @@ async def list_linkedin_campaigns(t: TenantContext = Depends(get_tenant_context)
                 "unipile_account_label": a.label if a else "",
                 "created_at": c.created_at.isoformat() if c.created_at else None,
                 "executed_at": c.executed_at.isoformat() if c.executed_at else None,
+                "execution_result": c.execution_result,
             }
             for c, a in rows
         ]
@@ -1315,9 +1426,13 @@ async def upload_linkedin_campaign_csv(
             GeneratedSequence.product == campaign.name,
         ).delete()
 
+    linkedin_profiles_detected = 0
     for idx, row in df.iterrows():
         row_dict = row.to_dict()
         sanitized_raw_data = {str(k): _json_safe(v) for k, v in row_dict.items()}
+        li_raw = _pick_linkedin_url(sanitized_raw_data)
+        if _linkedin_public_identifier(li_raw):
+            linkedin_profiles_detected += 1
         contact = Contact(
             tenant_id=t.tenant_id,
             file_id=file_id,
@@ -1337,7 +1452,12 @@ async def upload_linkedin_campaign_csv(
     campaign.status = "draft"
     campaign.updated_at = datetime.utcnow()
     db.commit()
-    return {"file_id": file_id, "contact_count": contact_count, "message": "Campaign CSV uploaded"}
+    return {
+        "file_id": file_id,
+        "contact_count": contact_count,
+        "linkedin_profiles_detected": linkedin_profiles_detected,
+        "message": "Campaign CSV uploaded",
+    }
 
 
 @app.post("/api/linkedin-campaigns/{campaign_id}/generate")
@@ -1462,8 +1582,14 @@ async def execute_linkedin_campaign(
     t: TenantContext = Depends(get_tenant_context),
 ):
     """
-    Execute generated LinkedIn campaign via UniPile.
-    This sends the first generated message per contact using UniPile chat-message route.
+    Execute LinkedIn campaign via UniPile.
+
+    Sends a connection request using POST /users/invite with the first generated step as the
+    invite note (visible under LinkedIn → My Network → Manage invitations → Sent).
+
+    UniPile expects the public /in/{{slug}} identifier plus account_id on profile lookup — not a raw URL path.
+
+    If the invite cannot be sent (e.g. already connected), falls back to a 1:1 LinkedIn DM via chats API.
     """
     db = t.db
     campaign = (
@@ -1512,87 +1638,236 @@ async def execute_linkedin_campaign(
         .order_by(GeneratedSequence.sequence_id.asc())
         .all()
     )
+    if not seq_rows:
+        raise HTTPException(
+            status_code=400,
+            detail="Generate LinkedIn sequences before executing the campaign.",
+        )
     msg_by_seq = {r.sequence_id: r for r in seq_rows}
 
-    sent = 0
+    invite_sent = 0
+    dm_sent = 0
+    dry_preview = 0
     skipped = 0
     failed = 0
     errors = []
     attempts = []
 
+    acc_uid = account.unipile_account_id
+
+    def _contact_label(cr: Contact) -> str:
+        parts = [_safe_str(cr.first_name), _safe_str(cr.last_name)]
+        lab = " ".join(p for p in parts if p).strip()
+        return lab or "Contact"
+
     for idx, c in enumerate(contacts, start=1):
         first_msg = msg_by_seq.get(idx)
+        name_label = _contact_label(c)
         if not first_msg:
             skipped += 1
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "status": "skipped",
+                    "reason": "no_generated_message",
+                }
+            )
             continue
-        linkedin_url = _pick_linkedin_url(c.raw_data or {})
-        if not linkedin_url:
+
+        raw_li = _pick_linkedin_url(c.raw_data or {})
+        url_disp = _normalize_linkedin_url(raw_li) or _safe_str(raw_li)
+        slug = _linkedin_public_identifier(raw_li)
+
+        if not slug:
             skipped += 1
             errors.append(
                 {
                     "contact_id": c.id,
                     "reason": "missing_linkedin_url",
-                    "message": "No LinkedIn profile URL column found for this contact.",
+                    "message": "No usable LinkedIn profile URL (expected Apollo-style Person Linkedin Url or /in/{{slug}}).",
+                }
+            )
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "status": "skipped",
+                    "reason": "missing_or_invalid_linkedin_url",
                 }
             )
             continue
+
+        note = _linkedin_invite_note(first_msg.email_content or "")
+
         if body.dry_run:
-            sent += 1
-            attempts.append({"contact_id": c.id, "linkedin_url": linkedin_url, "status": "dry_run"})
+            dry_preview += 1
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "status": "dry_run",
+                    "detail": "Dry run: no UniPile calls. Uncheck the Dry run checkbox to send connection invites.",
+                    "invite_note_preview": note[:180],
+                }
+            )
             continue
-        try:
-            # Best-effort execution path:
-            # 1) resolve profile from identifier
-            profile = _unipile_request(
-                "GET",
-                f"/api/v1/users/{requests.utils.quote(linkedin_url, safe='')}",
+
+        slug_enc = requests.utils.quote(slug, safe="")
+        acc_enc = requests.utils.quote(acc_uid, safe="")
+        st_prof, profile = _unipile_call("GET", f"/api/v1/users/{slug_enc}?account_id={acc_enc}")
+
+        if st_prof >= 400 or not isinstance(profile, dict):
+            failed += 1
+            detail = profile if isinstance(profile, dict) else {}
+            msg = (
+                detail.get("message")
+                or detail.get("detail")
+                or detail.get("error")
+                or (json.dumps(detail)[:800] if detail else "profile lookup failed")
+            )
+            if isinstance(msg, (dict, list)):
+                msg = json.dumps(msg)
+            errors.append({"contact_id": c.id, "reason": "profile_lookup_failed", "message": str(msg)})
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "status": "failed",
+                    "step": "resolve_profile",
+                    "detail": str(msg)[:500],
+                }
+            )
+            continue
+
+        provider_id = _safe_str(profile.get("provider_id"))
+        rel_hint = _safe_str(
+            profile.get("network_distance") or profile.get("distance") or ""
+        )
+        if not rel_hint and isinstance(profile.get("relation"), dict):
+            rel_hint = _safe_str((profile.get("relation") or {}).get("distance"))
+
+        if not provider_id:
+            failed += 1
+            errors.append(
+                {
+                    "contact_id": c.id,
+                    "reason": "missing_provider_id",
+                    "message": "UniPile profile response had no provider_id.",
+                }
             )
-            attendee_id = _safe_str(
-                profile.get("id") if isinstance(profile, dict) else ""
-            ) or _safe_str(profile.get("provider_id") if isinstance(profile, dict) else "")
-            if not attendee_id:
-                raise ValueError("UniPile profile id not found")
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "status": "failed",
+                    "step": "resolve_profile",
+                    "detail": "provider_id missing from UniPile profile payload",
+                }
+            )
+            continue
+
+        st_inv, inv_res = _unipile_call(
+            "POST",
+            "/api/v1/users/invite",
+            {"provider_id": provider_id, "account_id": acc_uid, "message": note},
+        )
 
-            # 2) start or reuse 1:1 chat
+        if st_inv < 400:
+            invite_sent += 1
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "provider_id": provider_id,
+                    "status": "invite_sent",
+                    "network_distance": rel_hint or None,
+                    "connection_hint": rel_hint or None,
+                }
+            )
+            continue
+
+        inv_err = ""
+        if isinstance(inv_res, dict):
+            inv_err = _safe_str(
+                inv_res.get("message") or inv_res.get("detail") or inv_res.get("error") or ""
+            )
+            if isinstance(inv_res.get("errors"), list):
+                inv_err = inv_err or json.dumps(inv_res.get("errors"))[:400]
+
+        try:
             chat = _unipile_request(
                 "POST",
                 "/api/v1/chats",
-                {
-                    "account_id": account.unipile_account_id,
-                    "attendees": [attendee_id],
-                },
+                {"account_id": acc_uid, "attendees": [provider_id]},
             )
             chat_id = _safe_str(chat.get("id") if isinstance(chat, dict) else "")
             if not chat_id:
                 raise ValueError("UniPile chat id not found")
-
-            # 3) send first generated LinkedIn message
             _unipile_request(
                 "POST",
-                f"/api/v1/chats/{chat_id}/messages",
+                f"/api/v1/chats/{requests.utils.quote(chat_id, safe='')}/messages",
+                {"text": first_msg.email_content or ""},
+            )
+            dm_sent += 1
+            attempts.append(
                 {
-                    "text": first_msg.email_content or "",
-                },
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "provider_id": provider_id,
+                    "status": "message_sent",
+                    "network_distance": rel_hint or None,
+                    "connection_hint": rel_hint or None,
+                    "fallback_from_invite_error": inv_err or None,
+                    "detail": "Connection invite was not sent (see fallback_from_invite_error); sent LinkedIn DM instead.",
+                }
             )
-            sent += 1
-            attempts.append({"contact_id": c.id, "linkedin_url": linkedin_url, "status": "sent"})
         except Exception as e:
             failed += 1
             errors.append(
                 {
                     "contact_id": c.id,
-                    "reason": "send_failed",
-                    "message": str(e),
+                    "reason": "invite_and_dm_failed",
+                    "message": f"invite: {inv_err}; dm: {str(e)}",
+                }
+            )
+            attempts.append(
+                {
+                    "contact_id": c.id,
+                    "name": name_label,
+                    "linkedin_url": url_disp,
+                    "public_identifier": slug,
+                    "status": "failed",
+                    "step": "invite_and_message",
+                    "invite_error": inv_err or None,
+                    "detail": str(e),
                 }
             )
 
+    total_ok = dry_preview if body.dry_run else (invite_sent + dm_sent)
     result = {
-        "sent": sent,
+        "dry_run": body.dry_run,
+        "dry_run_preview_count": dry_preview,
+        "linkedin_invites_sent": invite_sent,
+        "direct_messages_sent": dm_sent,
+        "sent": total_ok,
         "skipped": skipped,
         "failed": failed,
-        "errors": errors[:100],
-        "attempts": attempts[:100],
-        "dry_run": body.dry_run,
+        "errors": errors[:200],
+        "attempts": attempts[:500],
+        "execution_kind": "linkedin_connection_invite",
+        "help": "Invites appear under LinkedIn → My Network → Manage invitations → Sent. Dry run performs zero UniPile calls.",
     }
     campaign.status = "completed" if failed == 0 else "failed"
     campaign.execution_result = result

frontend/src/components/campaigns/LinkedinCampaignsTab.jsx

@@ -21,12 +21,17 @@ export default function LinkedinCampaignsTab() {
     const [promptTemplate, setPromptTemplate] = useState(
         'Write a concise LinkedIn message sequence (3 steps) personalized using first name, company, and title. Keep each message under 500 characters, human and non-spammy.'
     );
-    const [dryRun, setDryRun] = useState(true);
+    /** When true, the backend never calls UniPile — use once to validate rows, then turn off to send invites. */
+    const [dryRun, setDryRun] = useState(false);
 
     const selectedCampaign = useMemo(
         () => campaigns.find((c) => String(c.id) === String(selectedCampaignId)) || null,
         [campaigns, selectedCampaignId]
     );
+    const selectedAccount = useMemo(
+        () => accounts.find((a) => String(a.id) === String(createForm.unipile_account_ref_id)) || null,
+        [accounts, createForm.unipile_account_ref_id]
+    );
 
     const refreshAll = async () => {
         const [accRes, cmpRes] = await Promise.all([
@@ -113,7 +118,12 @@ export default function LinkedinCampaignsTab() {
             const data = await res.json().catch(() => ({}));
             if (!res.ok) throw new Error(data.detail || 'CSV upload failed');
             await refreshAll();
-            alert(`Uploaded ${data.contact_count || 0} contacts.`);
+            const li = data.linkedin_profiles_detected;
+            alert(
+                `Uploaded ${data.contact_count || 0} rows.${
+                    li != null ? ` LinkedIn profile URLs detected on ${li} rows (Apollo “Person Linkedin Url”).` : ''
+                }`
+            );
         } catch (e) {
             alert(e.message || 'CSV upload failed');
         } finally {
@@ -156,7 +166,15 @@ export default function LinkedinCampaignsTab() {
             const data = await res.json().catch(() => ({}));
             if (!res.ok) throw new Error(data.detail || 'Execution failed');
             await refreshAll();
-            alert(`Execution finished: sent=${data.sent}, skipped=${data.skipped}, failed=${data.failed}`);
+            if (data.dry_run) {
+                alert(
+                    `Dry run only — nothing was sent to LinkedIn or UniPile.\nContacts previewed: ${data.dry_run_preview_count ?? data.sent ?? 0}\n\nUncheck “Dry run” and execute again to send connection invites.`
+                );
+            } else {
+                alert(
+                    `Done.\nConnection invites sent: ${data.linkedin_invites_sent ?? 0}\nDirect messages (fallback): ${data.direct_messages_sent ?? 0}\nSkipped: ${data.skipped}\nFailed: ${data.failed}`
+                );
+            }
         } catch (e) {
             alert(e.message || 'Execution failed');
         } finally {
@@ -193,6 +211,38 @@ export default function LinkedinCampaignsTab() {
                 <div className="mt-3 text-sm text-slate-600">
                     Connected accounts: {accounts.length}
                 </div>
+                {accounts.length > 0 ? (
+                    <div className="mt-3 flex flex-wrap gap-2">
+                        {accounts.map((a) => {
+                            const n = a.display_name || a.label || 'LinkedIn account';
+                            const initials = n
+                                .split(/\s+/)
+                                .slice(0, 2)
+                                .map((s) => s[0] || '')
+                                .join('')
+                                .toUpperCase();
+                            return (
+                                <div
+                                    key={a.id}
+                                    className="inline-flex items-center gap-2 rounded-full border border-slate-200 bg-slate-50 px-2.5 py-1 text-xs text-slate-700"
+                                >
+                                    {a.avatar_url ? (
+                                        <img
+                                            src={a.avatar_url}
+                                            alt={n}
+                                            className="h-5 w-5 rounded-full object-cover"
+                                        />
+                                    ) : (
+                                        <span className="inline-flex h-5 w-5 items-center justify-center rounded-full bg-violet-100 text-[10px] font-semibold text-violet-700">
+                                            {initials || 'LI'}
+                                        </span>
+                                    )}
+                                    <span className="max-w-[210px] truncate">{n}</span>
+                                </div>
+                            );
+                        })}
+                    </div>
+                ) : null}
             </div>
 
             <div className="rounded-2xl border border-slate-200 bg-white p-5">
@@ -213,7 +263,7 @@ export default function LinkedinCampaignsTab() {
                         <option value="">Select LinkedIn account</option>
                         {accounts.map((a) => (
                             <option key={a.id} value={a.id}>
-                                {a.label} ({a.status || 'unknown'})
+                                {(a.display_name || a.label || 'LinkedIn account')} ({a.status || 'unknown'})
                             </option>
                         ))}
                     </select>
@@ -222,6 +272,11 @@ export default function LinkedinCampaignsTab() {
                         Create New
                     </Button>
                 </div>
+                {selectedAccount ? (
+                    <div className="mt-3 rounded-md border border-slate-200 bg-slate-50 px-3 py-2 text-sm text-slate-700">
+                        Using account: <strong>{selectedAccount.display_name || selectedAccount.label}</strong>
+                    </div>
+                ) : null}
                 <div className="mt-4">
                     <select
                         className="h-10 w-full rounded-md border border-slate-200 px-3 text-sm"
@@ -296,18 +351,95 @@ export default function LinkedinCampaignsTab() {
 
             <div className="rounded-2xl border border-slate-200 bg-white p-5">
                 <h3 className="mb-3 text-lg font-semibold text-slate-800">5) Execute Campaign via UniPile API</h3>
-                <label className="mb-3 flex items-center gap-2 text-sm text-slate-700">
-                    <input
-                        type="checkbox"
-                        checked={dryRun}
-                        onChange={(e) => setDryRun(e.target.checked)}
-                    />
-                    Dry run (recommended first)
+                <p className="mb-3 text-sm text-slate-600">
+                    Sends a <strong>LinkedIn connection request</strong> using your first generated message as the invite note
+                    (visible under LinkedIn → My Network → Manage invitations → Sent). If an invite cannot be sent (for example
+                    you are already connected), the app falls back to a direct message when possible.
+                </p>
+                {dryRun ? (
+                    <div className="mb-3 rounded-lg border border-amber-200 bg-amber-50 px-3 py-2 text-sm text-amber-950">
+                        <strong>Dry run is on.</strong> No requests go to UniPile and nothing appears on LinkedIn — including no
+                        invitations in “Sent”.
+                    </div>
+                ) : null}
+                <label className="mb-3 flex flex-col gap-1 text-sm text-slate-700 sm:flex-row sm:items-center sm:gap-2">
+                    <span className="inline-flex items-center gap-2">
+                        <input
+                            type="checkbox"
+                            checked={dryRun}
+                            onChange={(e) => setDryRun(e.target.checked)}
+                        />
+                        Dry run (preview only — no UniPile / LinkedIn activity)
+                    </span>
                 </label>
                 <Button onClick={executeCampaign} disabled={!selectedCampaignId || busy}>
                     <Play className="mr-2 h-4 w-4" />
                     Execute Campaign
                 </Button>
+
+                {selectedCampaign?.execution_result?.attempts?.length ? (
+                    <div className="mt-5 rounded-lg border border-slate-200 bg-slate-50/80 p-3">
+                        <div className="mb-2 flex flex-wrap items-center justify-between gap-2">
+                            <p className="text-sm font-semibold text-slate-800">Last run — per contact</p>
+                            {selectedCampaign.execution_result?.dry_run ? (
+                                <span className="rounded-full bg-amber-100 px-2 py-0.5 text-xs font-medium text-amber-900">
+                                    Dry run
+                                </span>
+                            ) : null}
+                        </div>
+                        <p className="mb-2 text-xs text-slate-600">
+                            {selectedCampaign.execution_result?.help ||
+                                'Statuses: invite_sent = connection request submitted; message_sent = DM (invite not used); dry_run = preview only.'}
+                        </p>
+                        <div className="max-h-72 overflow-auto rounded-md border border-slate-200 bg-white">
+                            <table className="w-full text-left text-xs">
+                                <thead className="sticky top-0 bg-slate-100 text-slate-700">
+                                    <tr>
+                                        <th className="px-2 py-1.5 font-medium">Name</th>
+                                        <th className="px-2 py-1.5 font-medium">Profile</th>
+                                        <th className="px-2 py-1.5 font-medium">Status</th>
+                                        <th className="px-2 py-1.5 font-medium">Note</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    {selectedCampaign.execution_result.attempts.map((row, i) => (
+                                        <tr key={`${row.contact_id}-${i}`} className="border-t border-slate-100">
+                                            <td className="px-2 py-1.5 align-top text-slate-800">{row.name || '—'}</td>
+                                            <td className="max-w-[200px] px-2 py-1.5 align-top">
+                                                <div className="truncate text-slate-600" title={row.linkedin_url || ''}>
+                                                    {row.public_identifier || row.linkedin_url || '—'}
+                                                </div>
+                                            </td>
+                                            <td className="whitespace-nowrap px-2 py-1.5 align-top font-medium text-slate-800">
+                                                {row.status === 'invite_sent'
+                                                    ? 'Invite sent'
+                                                    : row.status === 'message_sent'
+                                                      ? 'DM sent'
+                                                      : row.status === 'dry_run'
+                                                        ? 'Dry run'
+                                                        : row.status === 'skipped'
+                                                          ? 'Skipped'
+                                                          : row.status === 'failed'
+                                                            ? 'Failed'
+                                                            : row.status || '—'}
+                                            </td>
+                                            <td className="max-w-[240px] px-2 py-1.5 align-top text-slate-600">
+                                                {row.connection_hint || row.network_distance
+                                                    ? `Distance: ${row.connection_hint || row.network_distance}. `
+                                                    : ''}
+                                                {row.detail || row.invite_error || row.fallback_from_invite_error || row.reason || ''}
+                                            </td>
+                                        </tr>
+                                    ))}
+                                </tbody>
+                            </table>
+                        </div>
+                        <div className="mt-2 text-xs text-slate-500">
+                            LinkedIn does not expose “accepted” here in real time; check My Network for new connections. UniPile
+                            may include network distance on the profile response when available.
+                        </div>
+                    </div>
+                ) : null}
             </div>
         </div>
     );