Post-Event Contact Export

import asyncio
import csv
import logging
import os
import signal
import traceback
from datetime import datetime

from agent import ComputerAgent
from computer import Computer, VMProviderType
from dotenv import load_dotenv

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration: Define where you met these connections
MET_AT_REASON = "Google Devfest Toronto"

def handle_sigint(sig, frame):
    print("\n\nExecution interrupted by user. Exiting gracefully...")
    exit(0)

def extract_public_id_from_linkedin_url(linkedin_url):
    """Extract public ID from LinkedIn profile URL."""
    if not linkedin_url:
        return None

    url = linkedin_url.split('?')[0].rstrip('/')

    if '/in/' in url:
        public_id = url.split('/in/')[-1]
        return public_id

    return None

def extract_contact_from_response(result_output):
    """
    Extract contact information from agent's response.
    Expects format:
    FIRST: value
    LAST: value
    ROLE: value
    COMPANY: value
    LINKEDIN: value
    """
    contact = {
        'first': '',
        'last': '',
        'role': '',
        'company': '',
        'met_at': MET_AT_REASON,
        'linkedin': ''
    }

    for item in result_output:
        if item.get("type") == "message":
            content = item.get("content", [])
            for content_part in content:
                text = content_part.get("text", "")
                if text:
                    for line in text.split('\n'):
                        line = line.strip()
                        line_upper = line.upper()

                        if line_upper.startswith("FIRST:"):
                            value = line[6:].strip()
                            if value and value.upper() != "N/A":
                                contact['first'] = value
                        elif line_upper.startswith("LAST:"):
                            value = line[5:].strip()
                            if value and value.upper() != "N/A":
                                contact['last'] = value
                        elif line_upper.startswith("ROLE:"):
                            value = line[5:].strip()
                            if value and value.upper() != "N/A":
                                contact['role'] = value
                        elif line_upper.startswith("COMPANY:"):
                            value = line[8:].strip()
                            if value and value.upper() != "N/A":
                                contact['company'] = value
                        elif line_upper.startswith("LINKEDIN:"):
                            value = line[9:].strip()
                            if value and value.upper() != "N/A":
                                contact['linkedin'] = value

    return contact

async def scrape_linkedin_connections():
    """Scrape LinkedIn connections and export to CSV."""

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    csv_filename = f"linkedin_connections_{timestamp}.csv"
    csv_path = os.path.join(os.getcwd(), csv_filename)

    # Initialize CSV file
    with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=['first', 'last', 'role', 'company', 'met_at', 'linkedin'])
        writer.writeheader()

    print(f"\n🚀 Starting LinkedIn connections scraper")
    print(f"📁 Output file: {csv_path}")
    print(f"📍 Met at: {MET_AT_REASON}")
    print("=" * 80)

    try:
        async with Computer(
            os_type="linux",
            provider_type=VMProviderType.CLOUD,
            name=os.environ["CUA_CONTAINER_NAME"],  # Your sandbox name
            api_key=os.environ["CUA_API_KEY"],
            verbosity=logging.INFO,
        ) as computer:

            agent = ComputerAgent(
                model="cua/anthropic/claude-sonnet-4.5",
                tools=[computer],
                only_n_most_recent_images=3,
                verbosity=logging.INFO,
                trajectory_dir="trajectories",
                use_prompt_caching=True,
                max_trajectory_budget=10.0,
            )

            history = []

            # Task 1: Navigate to LinkedIn connections page
            navigation_task = (
                "STEP 1 - NAVIGATE TO LINKEDIN CONNECTIONS PAGE:\n"
                "1. Open a web browser (Chrome or Firefox)\n"
                "2. Navigate to https://www.linkedin.com/mynetwork/invite-connect/connections/\n"
                "3. Wait for the page to fully load\n"
                "4. Confirm you can see the list of connections\n"
                "5. Ready to start extracting contacts"
            )

            print(f"\n[Task 1/21] Navigating to LinkedIn...")
            history.append({"role": "user", "content": navigation_task})

            async for result in agent.run(history, stream=False):
                history += result.get("output", [])

            print(f"✅ Navigation completed\n")

            # Extract 20 contacts
            contacts_extracted = 0
            linkedin_urls = []
            previous_contact_name = None

            for contact_num in range(1, 21):
                # Build extraction task
                if contact_num == 1:
                    extraction_task = (
                        f"STEP {contact_num + 1} - EXTRACT CONTACT {contact_num} OF 20:\n"
                        f"1. Click on the first connection's profile\n"
                        f"2. Extract: FIRST, LAST, ROLE, COMPANY, LINKEDIN URL\n"
                        f"3. Return in exact format:\n"
                        f"FIRST: [value]\n"
                        f"LAST: [value]\n"
                        f"ROLE: [value]\n"
                        f"COMPANY: [value]\n"
                        f"LINKEDIN: [value]\n"
                        f"4. Navigate back to connections list"
                    )
                else:
                    extraction_task = (
                        f"STEP {contact_num + 1} - EXTRACT CONTACT {contact_num} OF 20:\n"
                        f"1. Find '{previous_contact_name}' in the list\n"
                        f"2. Click on the contact BELOW them\n"
                        f"3. Extract: FIRST, LAST, ROLE, COMPANY, LINKEDIN URL\n"
                        f"4. Return in exact format:\n"
                        f"FIRST: [value]\n"
                        f"LAST: [value]\n"
                        f"ROLE: [value]\n"
                        f"COMPANY: [value]\n"
                        f"LINKEDIN: [value]\n"
                        f"5. Navigate back"
                    )

                print(f"[Task {contact_num + 1}/21] Extracting contact {contact_num}/20...")
                history.append({"role": "user", "content": extraction_task})

                all_output = []
                async for result in agent.run(history, stream=False):
                    output = result.get("output", [])
                    history += output
                    all_output.extend(output)

                contact_data = extract_contact_from_response(all_output)

                has_name = bool(contact_data['first'] and contact_data['last'])
                has_linkedin = bool(contact_data['linkedin'] and 'linkedin.com' in contact_data['linkedin'])

                if has_name or has_linkedin:
                    with open(csv_path, 'a', newline='', encoding='utf-8') as csvfile:
                        writer = csv.DictWriter(csvfile, fieldnames=['first', 'last', 'role', 'company', 'met_at', 'linkedin'])
                        writer.writerow(contact_data)
                    contacts_extracted += 1

                    if contact_data['linkedin']:
                        linkedin_urls.append(contact_data['linkedin'])

                    if has_name:
                        previous_contact_name = f"{contact_data['first']} {contact_data['last']}".strip()

                    name_str = f"{contact_data['first']} {contact_data['last']}" if has_name else "[No name]"
                    print(f"✅ Contact {contact_num}/20 saved: {name_str}")
                else:
                    print(f"⚠️  Could not extract valid data for contact {contact_num}")

                if contact_num % 5 == 0:
                    print(f"\n📈 Progress: {contacts_extracted}/{contact_num} contacts extracted\n")

            # Create messaging links file
            messaging_filename = f"linkedin_messaging_links_{timestamp}.txt"
            messaging_path = os.path.join(os.getcwd(), messaging_filename)

            with open(messaging_path, 'w', encoding='utf-8') as txtfile:
                txtfile.write("LinkedIn Messaging Compose Links\n")
                txtfile.write("=" * 80 + "\n\n")

                for i, linkedin_url in enumerate(linkedin_urls, 1):
                    public_id = extract_public_id_from_linkedin_url(linkedin_url)
                    if public_id:
                        messaging_url = f"https://www.linkedin.com/messaging/compose/?recipient={public_id}"
                        txtfile.write(f"{i}. {messaging_url}\n")

            print("\n" + "="*80)
            print("🎉 All tasks completed!")
            print(f"📁 CSV file saved to: {csv_path}")
            print(f"📊 Total contacts extracted: {contacts_extracted}/20")
            print(f"💬 Messaging links saved to: {messaging_path}")
            print("="*80)

    except Exception as e:
        print(f"\n❌ Error: {e}")
        traceback.print_exc()
        raise

def main():
    try:
        load_dotenv()

        if "ANTHROPIC_API_KEY" not in os.environ:
            raise RuntimeError("Please set ANTHROPIC_API_KEY in .env")

        if "CUA_API_KEY" not in os.environ:
            raise RuntimeError("Please set CUA_API_KEY in .env")

        if "CUA_CONTAINER_NAME" not in os.environ:
            raise RuntimeError("Please set CUA_CONTAINER_NAME in .env")

        signal.signal(signal.SIGINT, handle_sigint)

        asyncio.run(scrape_linkedin_connections())

    except Exception as e:
        print(f"\n❌ Error: {e}")
        traceback.print_exc()

if __name__ == "__main__":
    main()

# Same code as Cloud Sandbox, but change Computer initialization to:
async with Computer(
    os_type="linux",
    provider_type=VMProviderType.DOCKER,
    image="trycua/cua-xfce:latest",
    verbosity=logging.INFO,
) as computer:

# Same code as Cloud Sandbox, but change Computer initialization to:
async with Computer(
    os_type="macos",
    provider_type=VMProviderType.LUME,
    name="macos-sequoia-cua:latest",
    verbosity=logging.INFO,
) as computer:

# Same code as Cloud Sandbox, but change Computer initialization to:
async with Computer(
    os_type="windows",
    provider_type=VMProviderType.WINDOWS_SANDBOX,
    verbosity=logging.INFO,
) as computer: