next

.claude/settings.local.json

@@ -26,7 +26,8 @@
       "Bash(pdflatex:*)",
       "Bash(initexmf:*)",
       "Bash(del /Q \"C:\\Users\\sumedh\\OneDrive - Georgia Institute of Technology\\Python\\Anthropic Hackathon - AI Apply\\generated_resumes\\*.*\")",
-      "Bash(git checkout:*)"
+      "Bash(git checkout:*)",
+      "WebSearch"
     ],
     "deny": [],
     "ask": []

CLAUDE.md

@@ -5,8 +5,8 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 ## Project Overview
 
 Flask web application for automated job outreach combining two workflows:
-1. **Email Campaigns**: Claude API finds contacts → generates personalized emails → sends via SMTP
-2. **Handshake DM Automation**: Selenium automates direct messages to recruiters on Handshake
+1. **Email Campaigns**: OpenRouter LLM finds contacts → generates personalized emails → sends via SMTP
+2. **Handshake DM Automation**: Playwright automates direct messages to recruiters on Handshake
 
 Key features: User authentication, SQLite persistence, real-time SSE progress updates, contact deduplication.
 
@@ -15,10 +15,13 @@ Key features: User authentication, SQLite persistence, real-time SSE progress up
 ```bash
 # Install and start
 pip install -r requirements.txt
+playwright install chromium  # Install Playwright browser
 python app.py  # Access at http://localhost:5000
 
-# Test ChromeDriver (for Handshake)
-python test_chromedriver.py
+# Test Playwright and LLM client
+python test_playwright.py          # Test browser automation
+python test_playwright.py --llm    # Test OpenRouter LLM client
+python test_playwright.py --all    # Test both
 
 # Run database migrations when schema changes
 python migrate_db.py
@@ -38,18 +41,18 @@ Three-stage **in-memory** pipeline (no intermediate files):
    - Checks both user history (DB) and global `workflow_company_log.json`
 
 3. **Email Generation & Sending**:
-   - `createEmailsUsingClaude(contacts, resume_path, custom_message)` → adds `email_body` field (resume as base64)
+   - `createEmailsUsingClaude(contacts, resume_path, custom_message)` → adds `email_body` field (resume extracted as text)
    - `SendEmailWorkFlowV2.main()` → sends via `SimpleEmailer` with rate limiting
 
 ### Handshake DM Workflow
 Browser automation with manual login (`HandshakeDMAutomation.py`):
 
-1. Selenium WebDriver opens Chrome (visible, not headless)
+1. Playwright opens Chromium browser (visible, not headless)
 2. User logs in manually → clicks "I'm Logged In" UI button
-3. Claude API maps user's industry to Handshake taxonomy + geocodes city
+3. OpenRouter LLM maps user's industry to Handshake taxonomy + geocodes city
 4. `sendAllDMs()` iterates employer pages:
    - Checks `handshake_dm_log.json` for duplicates
-   - Finds recruiter profiles → generates personalized message (Claude + resume PDF)
+   - Finds recruiter profiles → generates personalized message (LLM + resume text)
    - Automates Message button → enters text → sends
    - Saves company to log after success
 
@@ -82,9 +85,10 @@ Methods: `get_contacted_domains()`, `add_sent_emails()`, `add_contact_history()`
 ## Key Implementation Details
 
 ### API Configuration
-- **Claude API key**: `setup.py` as `API_KEY` (⚠️ DO NOT commit `setup.py` - add to `.gitignore`)
+- **OpenRouter API key**: Environment variable `OPENROUTER_API_KEY` in `.env` file
+- **LLM Client**: `llm_client.py` provides singleton wrapper using OpenAI SDK with OpenRouter base URL
 - **SMTP credentials**: Per-user in DB (`User.sender_email`, `User.sender_password`)
-- **Current model**: `claude-sonnet-4-20250514` (update in `EmailFinderUsingClaude.py` and `HandshakeDMAutomation.py`)
+- **Current model**: `xiaomi/mimo-v2-flash:free` (configured in `llm_client.py`)
 
 ### Deduplication Strategy
 **Email**: Check `User.emails_sent_history` + `User.get_contacted_domains()` + `workflow_company_log.json`
@@ -92,12 +96,12 @@ Methods: `get_contacted_domains()`, `add_sent_emails()`, `add_contact_history()`
 
 Both systems prevent re-contacting same company/domain.
 
-### Claude Prompt Patterns
+### LLM Prompt Patterns
 1. **Contact Discovery**: Returns JSON `[{company_name, contact_name, email_address}]` with `contact_name: null` for generic emails
-2. **Email Generation**: Resume PDF as base64 document attachment → JSON with `email_body` field
+2. **Email Generation**: Resume text extracted via `pdf_utils.py` → JSON with `email_body` field
 3. **Handshake Industry**: Maps user input to 100+ Handshake categories (cleantech forced to "Utilities & Renewable Energy")
 4. **Handshake Location**: Converts "City, State" to lat/long (requires comma in input)
-5. **Handshake DM**: 3-4 sentence limit, resume PDF attachment, handles "Dr. Name\nTitle" format
+5. **Handshake DM**: 3-4 sentence limit, resume text included in prompt, handles "Dr. Name\nTitle" format
 
 ### SimpleEmailer (`SimpleEmailer.py`)
 - Auto-detects SMTP server from email domain (Gmail, Office365, Yahoo, etc.)
@@ -105,13 +109,14 @@ Both systems prevent re-contacting same company/domain.
 - Logs to `email_log_YYYYMMDD.log`
 - Subject line hardcoded in `SendEmailWorkFlowV2.py:18`
 
-### Handshake Automation Quirks
+### Handshake Automation (Playwright)
 - Browser visible by default (users see automation)
 - Manual login required (no credential storage)
 - 30-second wait before closing browser
-- Multiple XPath selectors tried in sequence (Handshake DOM changes)
+- Multiple CSS/XPath selectors tried via `find_element_with_fallback()` (Handshake DOM changes)
 - URL encoding: `[]` → `%5B%5D` for filter URLs
 - Requires `Industry Codes Handshake.xlsx` for industry code lookup
+- Anti-detection: `playwright-stealth` + custom init scripts to hide automation
 
 ## Common Development Tasks
 
@@ -138,6 +143,7 @@ if progress_callback:
 
 ### Test Individual Modules
 ```bash
+python test_playwright.py          # Test browser + LLM setup
 python EmailFinderUsingClaude.py   # Update credentials in __main__ block
 python HandshakeDMAutomation.py
 python SimpleEmailer.py
@@ -151,9 +157,15 @@ python SimpleEmailer.py
 **Email logs**: `email_log_YYYYMMDD.log`
 **Temp uploads**: `uploads/` (cleaned after processing)
 
+### Utility Modules
+- **`llm_client.py`**: OpenRouter API wrapper using OpenAI SDK, singleton pattern via `get_client()`
+- **`pdf_utils.py`**: PDF text extraction using PyPDF2
+- **`browser_utils.py`**: Playwright browser manager with anti-detection, helper functions `find_element_with_fallback()`, `scroll_to_bottom()`
+
 ## Known Limitations
 
-- **Security**: API keys in `setup.py`, unencrypted SMTP passwords in DB, placeholder Flask secret key
+- **Security**: API keys in `.env` file, unencrypted SMTP passwords in DB, placeholder Flask secret key
 - **Scalability**: SQLite (single-threaded writes), in-memory SSE queues, no Celery
-- **Error Handling**: No retry logic for Claude API/SMTP failures, brittle XPath selectors for Handshake DOM
-- **Platform**: Windows paths, Chrome required, Selenium may break on Chrome updates
+- **Error Handling**: No retry logic for OpenRouter API/SMTP failures, brittle selectors for Handshake DOM
+- **Platform**: Windows paths, Chromium required (auto-installed via `playwright install chromium`)
+- **LLM**: MiMo v2 Flash doesn't support PDF attachments; PDFs are converted to text first

CoverLetterGenerator.py

@@ -1,20 +1,19 @@
 """
 Cover Letter Generation Module for ATS Optimization
 
-This module uses Claude API to analyze job descriptions and generate
-tailored cover letters as professional LaTeX PDFs.
+This module uses OpenRouter API (MiMo v2 Flash) to analyze job descriptions
+and generate tailored cover letters as professional LaTeX PDFs.
 """
 
 import os
 import re
 import json
 import shutil
-import anthropic
-import setup
 import subprocess
 from datetime import datetime
 from pathlib import Path
 from PyPDF2 import PdfReader
+from llm_client import get_client
 
 
 def check_latex_installation():
@@ -59,12 +58,7 @@ class ATSCoverLetterGenerator:
         self.resume_text = resume_text
         self.candidate_name = candidate_name
         self.candidate_email = candidate_email
-        self.claude_api_key = setup.API_KEY
-
-        if not self.claude_api_key or not self.claude_api_key.startswith('sk-ant-'):
-            raise ValueError("Invalid API key in setup.py")
-
-        self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
+        self.llm_client = get_client()
 
         # Create directories for generated cover letters
         self.generated_letters_dir = os.path.join(os.path.dirname(__file__), "generated_cover_letters")
@@ -124,14 +118,8 @@ Return ONLY a JSON object with the following structure (no markdown, no code blo
 IMPORTANT: Each paragraph should be a complete, grammatically correct paragraph. Do not use placeholder text."""
 
         try:
-            response = self.claude_client.messages.create(
-                model="claude-sonnet-4-5-20250929",
-                max_tokens=2000,
-                messages=[{"role": "user", "content": prompt}]
-            )
-
-            # Parse response
-            response_text = response.content[0].text.strip()
+            response_text = self.llm_client.create_message(prompt, max_tokens=2000)
+            response_text = response_text.strip()
 
             # Remove markdown code blocks if present
             if response_text.startswith("```"):

EmailFinderUsingClaude.py

@@ -1,10 +1,11 @@
 import json
 import requests
 import os
-from anthropic import Anthropic
 import FindEmailWorkFlowV2
 import SendEmailWorkFlowV2
 import setup
+from llm_client import get_client
+from pdf_utils import extract_text_from_pdf
 
 # Hunter.io API Key - Replace with your actual API key
 HUNTER_API_KEY = setup.HUNTER_API_KEY
@@ -57,13 +58,13 @@ def load_legacy_excel_emails(excel_path="Workflow Company Log.xlsx"):
 
     return emails, domains
 
-def askClaudeToFindCompanies(api_key, location="Atlanta", industry="Clean Tech", num_companies=5):
+def askClaudeToFindCompanies(api_key=None, location="Atlanta", industry="Clean Tech", num_companies=5):
     """
-    Uses Claude API to find startup companies based on location and industry.
+    Uses OpenRouter API to find startup companies based on location and industry.
     Returns only company names and domains (no emails or contacts).
 
     Args:
-        api_key: Anthropic API key for Claude API access
+        api_key: Deprecated, kept for backwards compatibility
         location: City or region to search for companies (default: "Atlanta")
         industry: Industry type to target (default: "Clean Tech")
         num_companies: Number of companies to find (default: 5)
@@ -71,7 +72,7 @@ def askClaudeToFindCompanies(api_key, location="Atlanta", industry="Clean Tech",
     Returns:
         list: List of dicts with keys: company_name, domain
     """
-    client = Anthropic(api_key=api_key)
+    client = get_client()
 
     # Build industry-specific guidance
     industry_examples = ""
@@ -88,49 +89,40 @@ def askClaudeToFindCompanies(api_key, location="Atlanta", industry="Clean Tech",
     else:
         industry_examples = f"({industry} related technologies and services)"
 
-    message = client.messages.create(
-        model="claude-sonnet-4-5-20250929",
-        max_tokens=4096,
-        messages=[
-            {
-                "role": "user",
-                "content": (
-                    "Return only a valid JSON array of objects with exactly two fields: "
-                    "company_name, domain.\n\n"
-                    f"Find {num_companies} real, actively operating {industry} companies based in the {location} area. "
-                    "These should be companies you have high confidence actually exist.\n\n"
-
-                    "DOMAIN REQUIREMENTS:\n"
-                    "- Provide the company's primary website domain (e.g., 'acmesolar.com', NOT 'www.acmesolar.com' or 'https://acmesolar.com')\n"
-                    "- The domain should be the company's actual corporate domain\n"
-                    "- Do NOT include protocol (http/https) or subdomains (www)\n"
-                    "- ONLY include domains you are highly confident are correct\n"
-                    "- If you cannot find the correct domain for a company, SKIP IT entirely\n\n"
-
-                    "COMPANY REQUIREMENTS:\n"
-                    f"- Only include companies working in {industry} {industry_examples}\n"
-                    f"- Companies must be based in or have significant presence in {location}\n"
-                    "- **CRITICAL: ONLY include startups and early-stage companies (NOT established enterprises)**\n"
-                    "- Startups typically have more open internship opportunities and are more responsive\n"
-                    "- Focus on companies with 10-200 employees (smaller is better)\n"
-                    "- Prefer recently founded companies (last 10 years) that are actively growing\n"
-                    "- Only include companies you have high confidence are real and currently operating\n\n"
-
-                    "QUALITY OVER QUANTITY:\n"
-                    f"- It is better to return fewer than {num_companies} companies with REAL domains\n"
-                    f"- than to return {num_companies} companies with guessed or uncertain domains\n"
-                    "- Each entry should represent a real company you can verify exists\n\n"
-
-                    "OUTPUT FORMAT:\n"
-                    "- Output only valid JSON with no markdown, explanations, or commentary\n"
-                    "- Example: [{\"company_name\": \"Acme Solar\", \"domain\": \"acmesolar.com\"}]\n"
-                    "- Example: [{\"company_name\": \"Green Energy Solutions\", \"domain\": \"greenenergysolutions.com\"}]"
-                ),
-            }
-        ],
+    prompt = (
+        "Return only a valid JSON array of objects with exactly two fields: "
+        "company_name, domain.\n\n"
+        f"Find {num_companies} real, actively operating {industry} companies based in the {location} area. "
+        "These should be companies you have high confidence actually exist.\n\n"
+
+        "DOMAIN REQUIREMENTS:\n"
+        "- Provide the company's primary website domain (e.g., 'acmesolar.com', NOT 'www.acmesolar.com' or 'https://acmesolar.com')\n"
+        "- The domain should be the company's actual corporate domain\n"
+        "- Do NOT include protocol (http/https) or subdomains (www)\n"
+        "- ONLY include domains you are highly confident are correct\n"
+        "- If you cannot find the correct domain for a company, SKIP IT entirely\n\n"
+
+        "COMPANY REQUIREMENTS:\n"
+        f"- Only include companies working in {industry} {industry_examples}\n"
+        f"- Companies must be based in or have significant presence in {location}\n"
+        "- **CRITICAL: ONLY include startups and early-stage companies (NOT established enterprises)**\n"
+        "- Startups typically have more open internship opportunities and are more responsive\n"
+        "- Focus on companies with 10-200 employees (smaller is better)\n"
+        "- Prefer recently founded companies (last 10 years) that are actively growing\n"
+        "- Only include companies you have high confidence are real and currently operating\n\n"
+
+        "QUALITY OVER QUANTITY:\n"
+        f"- It is better to return fewer than {num_companies} companies with REAL domains\n"
+        f"- than to return {num_companies} companies with guessed or uncertain domains\n"
+        "- Each entry should represent a real company you can verify exists\n\n"
+
+        "OUTPUT FORMAT:\n"
+        "- Output only valid JSON with no markdown, explanations, or commentary\n"
+        "- Example: [{\"company_name\": \"Acme Solar\", \"domain\": \"acmesolar.com\"}]\n"
+        "- Example: [{\"company_name\": \"Green Energy Solutions\", \"domain\": \"greenenergysolutions.com\"}]"
     )
 
-    response_text = message.content[0].text
+    response_text = client.create_message(prompt, max_tokens=4096)
 
 
     # Clean response text - remove markdown code blocks if present
@@ -284,85 +276,63 @@ def enrichCompaniesWithHunter(companies):
     return contacts
 
 
-def createEmailsUsingClaude(contacts, resume_path, api_key, industry="Clean Tech", custom_message=""):
+def createEmailsUsingClaude(contacts, resume_path, api_key=None, industry="Clean Tech", custom_message=""):
     """
-    Uses Claude API to generate personalized emails for each contact.
+    Uses OpenRouter API to generate personalized emails for each contact.
 
     Args:
         contacts: List of contact dicts from askClaudeToFindContacts
         resume_path: Path to PDF resume file
-        api_key: Anthropic API key for Claude API access
+        api_key: Deprecated, kept for backwards compatibility
         industry: Industry type to tailor email content (default: "Clean Tech")
         custom_message: Optional custom message to incorporate into emails (default: "")
 
     Returns:
         list: List of dicts with company_name, contact_name, email_address, email_body
     """
-    client = Anthropic(api_key=api_key)
+    client = get_client()
 
-    # Read and encode resume
-    with open(resume_path, "rb") as file:
-        import base64
-        file_data = file.read()
-        encoded_file = base64.standard_b64encode(file_data).decode("utf-8")
+    # Extract text from resume PDF
+    resume_text = extract_text_from_pdf(resume_path)
+    if not resume_text:
+        raise ValueError(f"Could not extract text from resume at {resume_path}")
 
-    # Create contact list text for Claude
+    # Create contact list text
     contact_text = json.dumps(contacts, indent=2)
 
-    message = client.messages.create(
-        model="claude-sonnet-4-5-20250929",
-        max_tokens=8000,
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": (
-                            f"You are helping draft personalized internship outreach emails for companies in the {industry} industry. "
-                            f"For each company listed below, create a tailored email that:\n\n"
-                            f"1. References specific work or projects the company is doing in {industry}\n"
-                            f"2. Connects the applicant's background (found in the resume) to the company's mission\n"
-                            f"3. Sounds authentic, human, and genuinely interested (NOT AI-generated)\n"
-                            f"4. Is professional but warm and conversational\n"
-                            f"5. Asks for internship opportunities without being pushy\n\n"
-                            f"6. Keeps the email concise (150-200 words)\n\n"
-                            f"7. Does not fabricate any information about the company or the applicant\n\n"
-                            f"{f'8. Incorporates this specific message/requirement: {custom_message}' if custom_message else ''}\n\n"
-                            f"Example email structure (adapt this based on the resume and each company):\n\n"
-                            f"Hi [Company Name Team],\n\n"
-                            f"I hope you're well. My name is [Name from resume], and I'm a [major/background from resume] student at [university from resume]. "
-                            f"I recently came across [Company Name]'s work on [specific project/technology in {industry}] and was fascinated by [specific technical aspect]. "
-                            f"I've spent time working on [relevant experience from resume], and I'd love to see how these skills might apply in a real-world, high-impact setting like yours. "
-                            f"My interest is to learn from experienced teams and contribute in any way I can, however small. "
-                            f"If there is a way for me to get involved with the technical side at [Company Name], I'd be grateful for the chance to discuss.\n\n"
-                            f"I've attached my resume for reference. Thank you very much for considering this note, and I appreciate any time or advice you can offer.\n\n"
-                            f"Best,\n[Name from resume]\n\n"
-                            f"IMPORTANT:\n"
-                            f"- Research each company and reference their actual work in {industry}\n"
-                            f"- Extract the applicant's name, university, and major from the resume\n"
-                            f"- Match skills from the resume to each company's focus area\n"
-                            f"- Make each email unique - no copy-paste language between companies\n"
-                            f"- Keep emails concise (150-200 words)\n\n"
-                            f"Company contacts:\n{contact_text}\n\n"
-                            f"Return a JSON array with the same contacts but add an 'email_body' field containing the tailored email body. "
-                            f"Do not include subject line or attachment information. Return only valid JSON with no additional text."
-                        ),
-                    },
-                    {
-                        "type": "document",
-                        "source": {
-                            "type": "base64",
-                            "media_type": "application/pdf",
-                            "data": encoded_file,
-                        },
-                    },
-                ],
-            }
-        ],
+    prompt = (
+        f"You are helping draft personalized internship outreach emails for companies in the {industry} industry. "
+        f"For each company listed below, create a tailored email that:\n\n"
+        f"1. References specific work or projects the company is doing in {industry}\n"
+        f"2. Connects the applicant's background (found in the resume) to the company's mission\n"
+        f"3. Sounds authentic, human, and genuinely interested (NOT AI-generated)\n"
+        f"4. Is professional but warm and conversational\n"
+        f"5. Asks for internship opportunities without being pushy\n\n"
+        f"6. Keeps the email concise (150-200 words)\n\n"
+        f"7. Does not fabricate any information about the company or the applicant\n\n"
+        f"{f'8. Incorporates this specific message/requirement: {custom_message}' if custom_message else ''}\n\n"
+        f"RESUME CONTENT:\n{resume_text}\n\n"
+        f"Example email structure (adapt this based on the resume and each company):\n\n"
+        f"Hi [Company Name Team],\n\n"
+        f"I hope you're well. My name is [Name from resume], and I'm a [major/background from resume] student at [university from resume]. "
+        f"I recently came across [Company Name]'s work on [specific project/technology in {industry}] and was fascinated by [specific technical aspect]. "
+        f"I've spent time working on [relevant experience from resume], and I'd love to see how these skills might apply in a real-world, high-impact setting like yours. "
+        f"My interest is to learn from experienced teams and contribute in any way I can, however small. "
+        f"If there is a way for me to get involved with the technical side at [Company Name], I'd be grateful for the chance to discuss.\n\n"
+        f"I've attached my resume for reference. Thank you very much for considering this note, and I appreciate any time or advice you can offer.\n\n"
+        f"Best,\n[Name from resume]\n\n"
+        f"IMPORTANT:\n"
+        f"- Research each company and reference their actual work in {industry}\n"
+        f"- Extract the applicant's name, university, and major from the resume\n"
+        f"- Match skills from the resume to each company's focus area\n"
+        f"- Make each email unique - no copy-paste language between companies\n"
+        f"- Keep emails concise (150-200 words)\n\n"
+        f"Company contacts:\n{contact_text}\n\n"
+        f"Return a JSON array with the same contacts but add an 'email_body' field containing the tailored email body. "
+        f"Do not include subject line or attachment information. Return only valid JSON with no additional text."
     )
 
-    response_text = message.content[0].text
+    response_text = client.create_message(prompt, max_tokens=8000)
     
 
     # Clean response text - remove markdown code blocks if present
@@ -437,15 +407,7 @@ def main(
     Returns:
         dict: Email sending results with success/failure counts and emails_sent list
     """
-    # Get API key from environment variable (more secure than hardcoding)
-    import os
-    api_key = setup.API_KEY
-
-    if not api_key:
-        raise ValueError(
-            "ANTHROPIC_API_KEY environment variable not set. "
-            "Please set it with your Claude API key from https://console.anthropic.com/"
-        )
+    # OpenRouter API key is loaded automatically by llm_client
 
     # Initialize user history if not provided
     if user_emails_sent is None:
@@ -486,9 +448,9 @@ def main(
         attempt += 1
         progress(f"Search attempt {attempt}/{max_attempts} (found {len(all_unique_contacts)}/{num_emails} unique contacts so far)...", 'in-progress')
 
-        # Step 1: Find companies using Claude (only company names and domains)
+        # Step 1: Find companies using LLM (only company names and domains)
         progress(f"Searching for {batch_size} {industry} companies...", 'in-progress')
-        companies = askClaudeToFindCompanies(api_key, location, industry, batch_size)
+        companies = askClaudeToFindCompanies(location=location, industry=industry, num_companies=batch_size)
         progress(f"Found {len(companies)} companies", 'success')
 
         if len(companies) == 0:
@@ -551,8 +513,8 @@ def main(
     final_contacts = all_unique_contacts[:num_emails]
 
     # Step 4: Generate personalized emails
-    progress(f"Generating {len(final_contacts)} personalized emails using Claude AI...", 'in-progress')
-    emails_with_bodies = createEmailsUsingClaude(final_contacts, resume_path, api_key, industry, custom_message)
+    progress(f"Generating {len(final_contacts)} personalized emails using AI...", 'in-progress')
+    emails_with_bodies = createEmailsUsingClaude(final_contacts, resume_path, industry=industry, custom_message=custom_message)
     progress(f"Created {len(emails_with_bodies)} personalized emails", 'success')
 
     # Step 5: Send emails

HandshakeDMAutomation.py

@@ -2,7 +2,7 @@
 Handshake Direct Message Automation Module
 
 This module automates sending direct messages to hiring managers on Handshake.
-It uses Selenium WebDriver to:
+It uses Playwright for browser automation to:
 1. Log into Handshake with user credentials
 2. Navigate directly to employer pages matching desired city and industry
 3. Filter by location and industry
@@ -18,21 +18,11 @@ import re
 import json
 import urllib
 import requests
-import anthropic
 import pandas as pd
-import setup
 from datetime import datetime
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service
-from selenium.common.exceptions import TimeoutException, NoSuchElementException, StaleElementReferenceException
-from webdriver_manager.chrome import ChromeDriverManager
-
-api_key = setup.API_KEY
+from browser_utils import BrowserManager, find_element_with_fallback, scroll_to_bottom
+from llm_client import get_client
+from pdf_utils import extract_text_from_pdf
 
 # Official Handshake Industry Categories (from Handshake Help Center)
 HANDSHAKE_INDUSTRIES = {
@@ -126,85 +116,28 @@ class HandshakeAutomator:
             headless: Run browser in headless mode (default: False for debugging)
         """
         self.headless = headless
-        self.driver = None
-        self.wait = None
+        self.browser_manager = None
+        self.page = None
 
-        # Claude API configuration
-        self.claude_api_key = api_key
-        if not self.claude_api_key:
-            raise ValueError(
-                "API_KEY not set in setup.py. "
-                "Please set it with your Claude API key from https://console.anthropic.com/"
-            )
-
-        # Validate API key format
-        if not self.claude_api_key.startswith('sk-ant-'):
-            raise ValueError(
-                f"Invalid API key format. API keys should start with 'sk-ant-'. "
-                f"Please check your API key in setup.py"
-            )
-
-        try:
-            self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
-        except Exception as e:
-            raise ValueError(
-                f"Failed to initialize Claude API client: {str(e)}. "
-                f"Please check your API key in setup.py"
-            )
+        # LLM client configuration (OpenRouter)
+        self.llm_client = get_client()
 
         # Company DM tracking log file
         self.dm_log_file = os.path.join(os.path.dirname(__file__), "handshake_dm_log.json")
 
     def setup_driver(self):
-        """Set up Chrome WebDriver with appropriate options."""
-        chrome_options = Options()
-
-        if self.headless:
-            chrome_options.add_argument('--headless=new')
-
-        # Stability and compatibility options
-        chrome_options.add_argument('--no-sandbox')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
-        chrome_options.add_argument('--disable-gpu')
-        chrome_options.add_argument('--disable-software-rasterizer')
-        chrome_options.add_argument('--window-size=1920,1080')
-        chrome_options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36')
-
-        # Disable automation flags
-        chrome_options.add_experimental_option('excludeSwitches', ['enable-automation', 'enable-logging'])
-        chrome_options.add_experimental_option('useAutomationExtension', False)
-
-        # Add error logging
-        chrome_options.add_argument('--enable-logging')
-        chrome_options.add_argument('--v=1')
-
+        """Set up Playwright browser with appropriate options."""
         try:
-            driver_path = ChromeDriverManager().install()
-            print(f"Using ChromeDriver at: {driver_path}")
-
-            self.driver = webdriver.Chrome(service=Service(driver_path), options=chrome_options)
-
-            capabilities = self.driver.capabilities
-            print(f"Chrome version: {capabilities.get('browserVersion', 'Unknown')}")
-            print(f"ChromeDriver version: {capabilities.get('chrome', {}).get('chromedriverVersion', 'Unknown')}")
-
-            self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
-                'source': '''
-                    Object.defineProperty(navigator, 'webdriver', {
-                        get: () => undefined
-                    })
-                '''
-            })
-
-            self.wait = WebDriverWait(self.driver, 20)
+            self.browser_manager = BrowserManager(headless=self.headless)
+            self.page = self.browser_manager.setup()
+            print(f"Playwright browser initialized successfully")
 
         except Exception as e:
-            print(f"Error setting up ChromeDriver: {str(e)}")
+            print(f"Error setting up Playwright browser: {str(e)}")
             print("Troubleshooting tips:")
-            print("1. Make sure Chrome browser is installed and up to date")
-            print("2. Try running: pip install --upgrade selenium webdriver-manager")
-            print("3. Close any existing Chrome instances")
+            print("1. Run: pip install playwright")
+            print("2. Run: playwright install chromium")
+            print("3. Close any existing browser instances")
             raise
 
     def load_contacted_companies(self):
@@ -255,7 +188,7 @@ class HandshakeAutomator:
 
     def login_to_handshake(self, progress_callback=None, login_confirmed_callback=None):
         """
-        Log into Handshake using provided credentials.
+        Log into Handshake using manual login.
         Handles case where user is already logged in from previous session.
 
         Args:
@@ -269,8 +202,8 @@ class HandshakeAutomator:
             if progress_callback:
                 progress_callback("Navigating to Handshake login page...", "in-progress")
 
-            self.driver.get("https://app.joinhandshake.com/login")
-            time.sleep(3)
+            self.page.goto("https://app.joinhandshake.com/login")
+            self.page.wait_for_timeout(3000)
 
             if progress_callback:
                 progress_callback("Please log into Handshake in the browser window, then click 'I'm Logged In' button below.", "login-wait")
@@ -298,23 +231,20 @@ class HandshakeAutomator:
                     progress_callback("Login timeout - please try again and click the button after logging in", "error")
                 return False
 
-            # Verify login by checking for job search page
+            # Verify login by checking for employers page
             try:
-                self.driver.get("https://app.joinhandshake.com/employers")
-                
-                time.sleep(3)
+                self.page.goto("https://app.joinhandshake.com/employers")
+                self.page.wait_for_timeout(3000)
 
-                # Check if we're on the jobs page
-                self.wait.until(
-                    EC.presence_of_element_located((By.XPATH, "./*"))
-                )
+                # Check if we're on the employers page
+                self.page.wait_for_selector("body", timeout=20000)
 
                 if progress_callback:
                     progress_callback("Successfully logged into Handshake!", "success")
-                
+
                 return True
 
-            except TimeoutException:
+            except Exception:
                 if progress_callback:
                     progress_callback("Login verification failed. Please ensure you're logged in.", "error")
                 return False
@@ -404,24 +334,13 @@ Return your answer as a JSON array of industry names EXACTLY as they appear in t
 Return ONLY the JSON array with no markdown formatting, nothing else. You must include at least 1 industry."""
 
             try:
-                response = self.claude_client.messages.create(
-                    model="claude-sonnet-4-5-20250929",
-                    max_tokens=300,
-                    messages=[{"role": "user", "content": prompt}]
-                )
-            except anthropic.AuthenticationError as auth_error:
-                print(f"❌ Claude API authentication failed: {str(auth_error)}")
-                print(f"Your API key in setup.py may be invalid or expired.")
-                print(f"Falling back to keyword matching...")
-                raise Exception(f"API authentication error: {str(auth_error)}")
+                response_text = self.llm_client.create_message(prompt, max_tokens=300)
+                response_text = response_text.strip()
             except Exception as api_error:
-                print(f"❌ Claude API error: {str(api_error)}")
+                print(f"❌ LLM API error: {str(api_error)}")
                 print(f"Falling back to keyword matching...")
                 raise Exception(f"API error: {str(api_error)}")
 
-            # Parse the response
-            response_text = response.content[0].text.strip()
-
             # Remove markdown code blocks if present
             if response_text.startswith("```"):
                 response_text = response_text.split("```")[1]
@@ -565,26 +484,14 @@ For example:
 Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown, just the string "lat,long"."""
 
             try:
-                response = self.claude_client.messages.create(
-                    model="claude-sonnet-4-5-20250929",
-                    max_tokens=100,
-                    messages=[{"role": "user", "content": prompt}]
-                )
-            except anthropic.AuthenticationError as auth_error:
-                raise ValueError(
-                    f"Claude API authentication failed: {str(auth_error)}\n"
-                    f"Your API key in setup.py may be invalid or expired.\n"
-                    f"Please get a new API key from https://console.anthropic.com/"
-                )
+                coordinates = self.llm_client.create_message(prompt, max_tokens=100)
+                coordinates = coordinates.strip()
             except Exception as api_error:
                 raise ValueError(
-                    f"Claude API error: {str(api_error)}\n"
+                    f"LLM API error: {str(api_error)}\n"
                     f"Please check your API key and internet connection."
                 )
 
-            # Parse the response - should be just the coordinates string
-            coordinates = response.content[0].text.strip()
-
             # Remove quotes if AI added them
             coordinates = coordinates.replace('"', '').replace("'", "")
 
@@ -618,51 +525,29 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
 
     
 
-    def extract_employer_urls(self,progress_callback=None):
-        time.sleep(5)
+    def extract_employer_urls(self, progress_callback=None):
+        self.page.wait_for_timeout(5000)
 
         # Scroll through the page to load all employer cards
         if progress_callback:
             progress_callback("Scrolling through page to load all employers...", "in-progress")
 
-        last_height = self.driver.execute_script("return document.body.scrollHeight")
-        scroll_attempts = 0
-        max_scroll_attempts = 10  # Prevent infinite scrolling
-
-        while scroll_attempts < max_scroll_attempts:
-            # Scroll down to bottom
-            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-            time.sleep(2)  # Wait for page to load
-
-            # Calculate new scroll height and compare with last scroll height
-            new_height = self.driver.execute_script("return document.body.scrollHeight")
-            if new_height == last_height:
-                # If heights are the same, we've reached the bottom
-                break
-            last_height = new_height
-            scroll_attempts += 1
-
-            if progress_callback:
-                progress_callback(f"Loading more employers... (scroll {scroll_attempts}/{max_scroll_attempts})", "in-progress")
-
-        # Scroll back to top to ensure all elements are accessible
-        self.driver.execute_script("window.scrollTo(0, 0);")
-        time.sleep(1)
+        scroll_to_bottom(self.page, max_scrolls=10, wait_time=2000)
 
         # Now extract all employer links
-        all_links=self.driver.find_elements(By.TAG_NAME,'a')
-        employer_urls=[]
-        employer_names=[]
+        all_links = self.page.locator('a').all()
+        employer_urls = []
+        employer_names = []
         for link in all_links:
-            href=link.get_attribute('href')
+            href = link.get_attribute('href')
             if href and '/e/' in href:
                 employer_urls.append(href)
-                employer_names.append(link.text.strip())
+                employer_names.append(link.text_content() or "")
 
         if progress_callback:
             progress_callback(f"Extracted {len(employer_urls)} employer URLs", "success")
 
-        return employer_urls,employer_names
+        return employer_urls, employer_names
     
     def clean_company_name(self, raw_company_name):
         """
@@ -687,21 +572,21 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
         # Return cleaned name or fallback
         return clean_name if clean_name else "Unknown Company"
 
-    def find_recruiter_name(self,progress_callback=None):
+    def find_recruiter_name(self, progress_callback=None):
         """
         Extract recruiter's name from their Handshake profile page.
 
         Returns:
             str: Recruiter's name, or None if not found
         """
-        all_names=self.driver.find_elements(By.TAG_NAME,'h1')
-        person_name=[]
+        all_names = self.page.locator('h1').all()
         for name in all_names:
-            val=name.text.strip()
+            val = name.text_content() or ""
+            val = val.strip()
             if "Message" in val:
                 # Extract name after "Message" text
                 # Example: "Message Dr. Alice Wonderland" -> "Dr. Alice Wonderland"
-                recruiter_name = val.split("Message",1)[1].strip()
+                recruiter_name = val.split("Message", 1)[1].strip()
 
                 # If the name has newlines (e.g., "Dr. Alice Wonderland\nDoctor of Research"),
                 # take only the first line (the actual name)
@@ -723,39 +608,37 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
         """
         try:
             # Strategy 1: Look for h2 elements that might contain job title
-            all_h2 = self.driver.find_elements(By.TAG_NAME, 'h2')
+            all_h2 = self.page.locator('h2').all()
             for h2 in all_h2:
-                text = h2.text.strip()
+                text = (h2.text_content() or "").strip()
                 # Filter out common non-title headers
                 if text and text not in ['Message', 'About', 'Education', 'Experience', 'Skills']:
                     # This might be the job title
                     if len(text) < 100:  # Reasonable length for a job title
                         return text
 
-            # Strategy 2: Look for elements with specific classes (may vary based on Handshake's HTML)
-            # Try common job title selectors
+            # Strategy 2: Look for elements with specific classes
             job_title_selectors = [
-                (By.CSS_SELECTOR, '[class*="job-title"]'),
-                (By.CSS_SELECTOR, '[class*="title"]'),
-                (By.CSS_SELECTOR, '[class*="position"]'),
-                (By.XPATH, '//div[contains(@class, "profile")]//p[1]'),
+                '[class*="job-title"]',
+                '[class*="title"]',
+                '[class*="position"]',
+                'div[class*="profile"] p:first-child',
             ]
 
-            for by_method, selector in job_title_selectors:
+            for selector in job_title_selectors:
                 try:
-                    elements = self.driver.find_elements(by_method, selector)
+                    elements = self.page.locator(selector).all()
                     for elem in elements:
-                        text = elem.text.strip()
+                        text = (elem.text_content() or "").strip()
                         if text and len(text) < 100 and '\n' not in text:
                             return text
                 except:
                     continue
 
             # Strategy 3: Extract from recruiter name element if it contains title
-            # Example: "Dr. Alice Wonderland\nDoctor of Research, Research Labs"
-            all_names = self.driver.find_elements(By.TAG_NAME, 'h1')
+            all_names = self.page.locator('h1').all()
             for name in all_names:
-                val = name.text.strip()
+                val = (name.text_content() or "").strip()
                 if "Message" in val:
                     # Remove "Message" prefix
                     remaining_text = val.split("Message", 1)[1].strip()
@@ -763,7 +646,6 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                     if '\n' in remaining_text:
                         lines = remaining_text.split('\n')
                         if len(lines) > 1:
-                            # Second line might be "Doctor of Research, Research Labs"
                             potential_title = lines[1].strip()
                             if potential_title:
                                 return potential_title
@@ -778,48 +660,24 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
 
     def find_recruiter_url(self):
         print('reached find recruiter url')
-        time.sleep(5)
+        self.page.wait_for_timeout(5000)
 
         # Scroll through the page to ensure all recruiter profiles are loaded
-        last_height = self.driver.execute_script("return document.body.scrollHeight")
-        scroll_attempts = 0
-        max_scroll_attempts = 5  # Employer pages are usually shorter
-
-        while scroll_attempts < max_scroll_attempts:
-            # Scroll down to bottom
-            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-            time.sleep(1.5)  # Wait for content to load
-
-            # Calculate new scroll height and compare with last scroll height
-            new_height = self.driver.execute_script("return document.body.scrollHeight")
-            if new_height == last_height:
-                # If heights are the same, we've reached the bottom
-                break
-            last_height = new_height
-            scroll_attempts += 1
-
-        # Scroll back to top to ensure all elements are accessible
-        self.driver.execute_script("window.scrollTo(0, 0);")
-        time.sleep(1)
+        scroll_to_bottom(self.page, max_scrolls=5, wait_time=1500)
 
         # Now extract all recruiter profile links
-        all_links=self.driver.find_elements(By.TAG_NAME,'a')
-        person_links=[]
-        person_name=[]
-        time.sleep(2)
+        all_links = self.page.locator('a').all()
+        person_links = []
+        person_name = []
+        self.page.wait_for_timeout(2000)
         for link in all_links:
-            #print(link.text)
-            href=link.get_attribute('href')
+            href = link.get_attribute('href')
             if href and '/profiles/' in href:
                 person_links.append(href)
-                person_name.append(link.text.strip())
-        if len(person_name)>=2 & len(person_links)>=2:
-            #print(person_name[1])
-            #print(person_links[1])
-            #print('reached end of find recruiter url: returned tuple')
-            return person_links[1],person_name[1]
+                person_name.append((link.text_content() or "").strip())
+        if len(person_name) >= 2 and len(person_links) >= 2:
+            return person_links[1], person_name[1]
         else:
-            #print('reached end of find recruiter url: returned nothing')
             return False
     
     
@@ -855,13 +713,13 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                     progress_callback(f"Skipped '{company_name}' (already contacted)", "info")
                 continue
 
-            self.driver.get(employer_urls[i])
-            time.sleep(3)
+            self.page.goto(employer_urls[i])
+            self.page.wait_for_timeout(3000)
             if(self.find_recruiter_url()):
-                recruiter_url,recruiter_name=self.find_recruiter_url()
+                recruiter_url, recruiter_name = self.find_recruiter_url()
                 if recruiter_url:
-                    self.driver.get(recruiter_url)
-                    time.sleep(3)
+                    self.page.goto(recruiter_url)
+                    self.page.wait_for_timeout(3000)
 
                     # Extract recruiter name
                     nombre=self.find_recruiter_name(progress_callback)
@@ -928,29 +786,19 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
             if progress_callback:
                 progress_callback("Opening message composer...", "in-progress")
 
-            time.sleep(3)
+            self.page.wait_for_timeout(3000)
 
-            # Find and click the Message button
+            # Find and click the Message button using Playwright selectors
             message_button_selectors = [
-                "//button[contains(text(), 'Message')]",
-                "//button[text()='Message']",
-                "//button[@aria-label='Message']",
-                "//a[contains(text(), 'Message')]",
-                "//button[contains(@class, 'message')]",
-                "//*[contains(text(), 'Message') and (self::button or self::a)]"
+                "button:has-text('Message')",
+                "button[aria-label='Message']",
+                "a:has-text('Message')",
+                "button[class*='message']",
+                "xpath=//button[contains(text(), 'Message')]",
+                "xpath=//*[contains(text(), 'Message') and (self::button or self::a)]"
             ]
 
-            message_button = None
-            for selector in message_button_selectors:
-                try:
-                    message_button = WebDriverWait(self.driver, 5).until(
-                        EC.element_to_be_clickable((By.XPATH, selector))
-                    )
-                    if message_button:
-                        print(f"✓ Found message button using selector: {selector}")
-                        break
-                except:
-                    continue
+            message_button = find_element_with_fallback(self.page, message_button_selectors, timeout=5000)
 
             if not message_button:
                 if progress_callback:
@@ -960,89 +808,62 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
             # Click the message button
             message_button.click()
             print("✓ Clicked message button")
-            time.sleep(3)  # Give time for messaging interface to load
+            self.page.wait_for_timeout(3000)  # Give time for messaging interface to load
 
             # Wait for the message composer to be fully loaded
-            # Check if we're now in a messaging interface (modal or separate page)
             if progress_callback:
                 progress_callback("Waiting for message composer to load...", "in-progress")
 
             # Try multiple strategies to find the message input
-            message_box = None
             message_box_selectors = [
-                (By.TAG_NAME, 'textarea'),
-                (By.CSS_SELECTOR, 'textarea[placeholder*="message" i]'),
-                (By.CSS_SELECTOR, 'textarea[placeholder*="Message" i]'),
-                (By.CSS_SELECTOR, 'textarea[aria-label*="message" i]'),
-                (By.CSS_SELECTOR, 'div[contenteditable="true"]'),  # Rich text editor
-                (By.XPATH, '//textarea[contains(@placeholder, "Type")]'),
-                (By.XPATH, '//div[@role="textbox"]')
+                "textarea",
+                "textarea[placeholder*='message' i]",
+                "textarea[placeholder*='Message' i]",
+                "textarea[aria-label*='message' i]",
+                "div[contenteditable='true']",
+                "div[role='textbox']",
+                "xpath=//textarea[contains(@placeholder, 'Type')]"
             ]
 
-            for by_method, selector in message_box_selectors:
-                try:
-                    message_box = WebDriverWait(self.driver, 10).until(
-                        EC.presence_of_element_located((by_method, selector))
-                    )
-                    if message_box:
-                        # Verify it's visible and interactable
-                        if message_box.is_displayed():
-                            print(f"✓ Found message input using: {by_method} - {selector}")
-                            break
-                        else:
-                            message_box = None
-                except:
-                    continue
+            message_box = find_element_with_fallback(self.page, message_box_selectors, timeout=10000)
 
             if not message_box:
                 if progress_callback:
                     progress_callback("Message input box not found in messaging interface.", "error")
                 return False
 
+            print(f"✓ Found message input")
+
             # Clear any existing text and enter the message
             if progress_callback:
                 progress_callback("Composing message...", "in-progress")
 
-            try:
-                message_box.clear()
-            except:
-                # Some elements don't support clear(), try selecting all and deleting
-                message_box.send_keys(Keys.CONTROL + "a")
-                message_box.send_keys(Keys.DELETE)
-
             message_box.click()  # Ensure it's focused
-            time.sleep(0.5)
-            message_box.send_keys(message_text)
+            self.page.wait_for_timeout(500)
+
+            # Clear existing text
+            message_box.press("Control+a")
+            message_box.press("Delete")
+
+            # Type the message
+            message_box.fill(message_text)
             print(f"✓ Entered message text ({len(message_text)} characters)")
-            time.sleep(1.5)  # Wait for text to fully populate
+            self.page.wait_for_timeout(1500)  # Wait for text to fully populate
 
             # Find and click the Send button
             if progress_callback:
                 progress_callback("Sending message...", "in-progress")
 
             send_button_selectors = [
-                "//button[contains(text(), 'Send')]",
-                "//button[text()='Send']",
-                "//button[@type='submit' and contains(., 'Send')]",
-                "//button[contains(@aria-label, 'Send')]",
-                "//button[contains(@aria-label, 'send')]",
-                "//*[contains(text(), 'Send') and self::button]",
-                "//button[@type='submit']"  # Generic submit button
+                "button:has-text('Send')",
+                "button[type='submit']:has-text('Send')",
+                "button[aria-label*='Send']",
+                "button[aria-label*='send']",
+                "button[type='submit']",
+                "xpath=//button[contains(text(), 'Send')]"
             ]
 
-            send_button = None
-            for selector in send_button_selectors:
-                try:
-                    send_button = WebDriverWait(self.driver, 5).until(
-                        EC.element_to_be_clickable((By.XPATH, selector))
-                    )
-                    if send_button and send_button.is_displayed() and send_button.is_enabled():
-                        print(f"✓ Found send button using selector: {selector}")
-                        break
-                    else:
-                        send_button = None
-                except:
-                    continue
+            send_button = find_element_with_fallback(self.page, send_button_selectors, timeout=5000)
 
             if not send_button:
                 if progress_callback:
@@ -1052,16 +873,17 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
             # Click the send button
             send_button.click()
             print("✓ Clicked send button")
-            time.sleep(2)
+            self.page.wait_for_timeout(2000)
 
-            # Verify the message was sent by checking if:
-            # 1. The textarea is cleared/empty
-            # 2. The send button is disabled or no longer visible
-            # 3. No error messages appeared
+            # Verify the message was sent
             try:
-                # Check if message box is cleared (indicates successful send)
-                time.sleep(1)
-                current_text = message_box.get_attribute('value') or message_box.text
+                self.page.wait_for_timeout(1000)
+                # Try to get current text in message box
+                try:
+                    current_text = message_box.input_value() if message_box.is_visible() else ""
+                except:
+                    current_text = ""
+
                 if len(current_text.strip()) == 0:
                     print("✓ Message box cleared - message sent successfully")
                     if progress_callback:
@@ -1069,23 +891,15 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                     return True
                 else:
                     print(f"⚠ Message box still contains text: {current_text[:50]}...")
-                    # Don't fail immediately - message might still have been sent
                     if progress_callback:
                         progress_callback("Message sent (verification unclear)", "success")
                     return True
             except:
-                # If we can't verify, assume success since no error was thrown
                 print("✓ Message sent (could not verify, but no errors)")
                 if progress_callback:
                     progress_callback("Direct message sent successfully!", "success")
                 return True
 
-        except TimeoutException as e:
-            error_msg = f"Timeout while sending DM: {str(e)}"
-            print(f"✗ {error_msg}")
-            if progress_callback:
-                progress_callback(error_msg, "error")
-            return False
         except Exception as e:
             error_msg = f"Error sending DM: {str(e)}"
             print(f"✗ {error_msg}")
@@ -1125,11 +939,20 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
         try:
             greeting = f"Hi {recruiter_name}" if recruiter_name else "Hello"
 
+            # Extract text from resume PDF
+            resume_text = extract_text_from_pdf(user_resume_path)
+            if not resume_text:
+                print(f"⚠️ Could not extract text from resume, using fallback message")
+                raise ValueError("Could not extract resume text")
+
             prompt = f"""You are helping a student write a personalized, professional direct message to a hiring manager on Handshake.
 
 Company: {company_name}
 Hiring Manager: {recruiter_name or 'Unknown'}. Only use their full name or title (such as Dr.). So for example if the entry was 'Dr. Alice Wonderland\nDoctor of Research, Research Labs' you should only use 'Dr. Alice Wonderland' or 'Dr. Wonderland'.
 
+RESUME CONTENT:
+{resume_text}
+
 Write a short, professional direct message (3-4 sentences max) that:
 1. Expresses genuine interest in opportunities at {company_name}
 2. Highlights 1-2 relevant skills or experiences from the resume that align with the company's industry
@@ -1141,43 +964,20 @@ Write a short, professional direct message (3-4 sentences max) that:
 Return ONLY the message body (no subject line, greeting, or signature). Start directly with the content.
 Do not include placeholders like [Your Name] - the message should be ready to send as-is."""
 
-            content = [{"type": "text", "text": prompt}]
-
-            # Load and attach resume (now mandatory)
-            with open(user_resume_path, 'rb') as f:
-                resume_data = f.read()
-                import base64
-                resume_base64 = base64.b64encode(resume_data).decode('utf-8')
-
-                content.append({
-                    "type": "document",
-                    "source": {
-                        "type": "base64",
-                        "media_type": "application/pdf",
-                        "data": resume_base64
-                    }
-                })
-
             try:
-                response = self.claude_client.messages.create(
-                    model="claude-sonnet-4-5-20250929",
-                    max_tokens=500,
-                    messages=[{"role": "user", "content": content}]
-                )
-
-                message_body = response.content[0].text.strip()
+                message_body = self.llm_client.create_message(prompt, max_tokens=500)
+                message_body = message_body.strip()
                 full_message = f"{greeting},\n\n{message_body}\n\nBest regards"
 
                 return full_message
 
-            except anthropic.AuthenticationError as auth_error:
-                print(f"❌ Claude API authentication failed: {str(auth_error)}")
-                print(f"Your API key in setup.py may be invalid or expired.")
+            except Exception as api_error:
+                print(f"❌ LLM API error: {str(api_error)}")
                 print(f"Using fallback message template...")
-                raise Exception(f"API authentication error: {str(auth_error)}")
+                raise Exception(f"API error: {str(api_error)}")
 
         except Exception as e:
-            print(f"Claude API error: {str(e)}")
+            print(f"LLM API error: {str(e)}")
             # Fallback to simple template
             return f"""{greeting},
 
@@ -1298,10 +1098,10 @@ Best regards"""
             if progress_callback:
                 progress_callback(f"Navigating to employer search page with filters...", "in-progress")
 
-            self.driver.get(filter_url)
+            self.page.goto(filter_url)
 
             # Wait for the page to load completely
-            time.sleep(5)
+            self.page.wait_for_timeout(5000)
 
             if progress_callback:
                 progress_callback("Employer search page loaded. Extracting employer information...", "in-progress")
@@ -1325,11 +1125,11 @@ Best regards"""
                 progress_callback(error_msg, "error")
 
         finally:
-            if self.driver is not None:
+            if self.browser_manager is not None:
                 try:
                     print("\nClosing browser in 10 seconds...")
                     time.sleep(10)
-                    self.driver.quit()
+                    self.browser_manager.close()
                     print("Browser closed successfully.")
                 except Exception as e:
                     print(f"Warning: Error closing browser: {str(e)}")

HandshakeJobApply.py

@@ -2,7 +2,7 @@
 Handshake Job Application Automation Module
 
 This module automates applying to jobs on Handshake.
-It uses Selenium WebDriver to:
+It uses Playwright for browser automation to:
 1. Log into Handshake with user credentials
 2. Navigate to job listings matching desired criteria
 3. Apply to relevant positions
@@ -14,24 +14,13 @@ import time
 import json
 import urllib
 import pandas as pd
-import anthropic
-import setup
 import ResumeGenerator
 import CoverLetterGenerator
 from PyPDF2 import PdfReader
 from datetime import datetime
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service
-from selenium.webdriver.common.action_chains import ActionChains
-from selenium.common.exceptions import TimeoutException, NoSuchElementException
-from webdriver_manager.chrome import ChromeDriverManager
-
-api_key = setup.API_KEY
+from browser_utils import BrowserManager, find_element_with_fallback, scroll_to_bottom
+from llm_client import get_client
+from pdf_utils import extract_text_from_pdf
 
 
 class HandshakeJobApplicator:
@@ -49,87 +38,30 @@ class HandshakeJobApplicator:
             user_id: User ID for database tracking
         """
         self.headless = headless
-        self.driver = None
-        self.wait = None
+        self.browser_manager = None
+        self.page = None
         self.resume_path = resume_path
         self.user_id = user_id
 
-        # Claude API configuration
-        self.claude_api_key = api_key
-        if not self.claude_api_key:
-            raise ValueError(
-                "API_KEY not set in setup.py. "
-                "Please set it with your Claude API key from https://console.anthropic.com/"
-            )
-
-        # Validate API key format
-        if not self.claude_api_key.startswith('sk-ant-'):
-            raise ValueError(
-                f"Invalid API key format. API keys should start with 'sk-ant-'. "
-                f"Please check your API key in setup.py"
-            )
-
-        try:
-            self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
-        except Exception as e:
-            raise ValueError(
-                f"Failed to initialize Claude API client: {str(e)}. "
-                f"Please check your API key in setup.py"
-            )
+        # LLM client configuration (OpenRouter)
+        self.llm_client = get_client()
 
         # Job application tracking log file
         self.application_log_file = os.path.join(os.path.dirname(__file__), "handshake_applications_log.json")
 
     def setup_driver(self):
-        """Set up Chrome WebDriver with appropriate options."""
-        chrome_options = Options()
-
-        if self.headless:
-            chrome_options.add_argument('--headless=new')
-
-        # Stability and compatibility options
-        chrome_options.add_argument('--no-sandbox')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
-        chrome_options.add_argument('--disable-gpu')
-        chrome_options.add_argument('--disable-software-rasterizer')
-        chrome_options.add_argument('--window-size=1920,1080')
-        chrome_options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36')
-
-        # Disable automation flags
-        chrome_options.add_experimental_option('excludeSwitches', ['enable-automation', 'enable-logging'])
-        chrome_options.add_experimental_option('useAutomationExtension', False)
-
-        # Add error logging
-        chrome_options.add_argument('--enable-logging')
-        chrome_options.add_argument('--v=1')
-
+        """Set up Playwright browser with appropriate options."""
         try:
-            driver_path = ChromeDriverManager().install()
-            print(f"Using ChromeDriver at: {driver_path}")
-
-            self.driver = webdriver.Chrome(service=Service(driver_path), options=chrome_options)
-
-            capabilities = self.driver.capabilities
-            print(f"Chrome version: {capabilities.get('browserVersion', 'Unknown')}")
-            print(f"ChromeDriver version: {capabilities.get('chrome', {}).get('chromedriverVersion', 'Unknown')}")
-
-            self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
-                'source': '''
-                    Object.defineProperty(navigator, 'webdriver', {
-                        get: () => undefined
-                    })
-                '''
-            })
-
-            self.wait = WebDriverWait(self.driver, 20)
+            self.browser_manager = BrowserManager(headless=self.headless)
+            self.page = self.browser_manager.setup()
+            print(f"Playwright browser initialized successfully")
 
         except Exception as e:
-            print(f"Error setting up ChromeDriver: {str(e)}")
+            print(f"Error setting up Playwright browser: {str(e)}")
             print("Troubleshooting tips:")
-            print("1. Make sure Chrome browser is installed and up to date")
-            print("2. Try running: pip install --upgrade selenium webdriver-manager")
-            print("3. Close any existing Chrome instances")
+            print("1. Run: pip install playwright")
+            print("2. Run: playwright install chromium")
+            print("3. Close any existing browser instances")
             raise
 
     def load_applied_jobs(self):
@@ -205,9 +137,8 @@ class HandshakeJobApplicator:
             if progress_callback:
                 progress_callback("Navigating to Handshake login page...", "in-progress")
 
-            self.driver.get("https://app.joinhandshake.com/login")
-            self.driver.fullscreen_window()
-            time.sleep(3)
+            self.page.goto("https://app.joinhandshake.com/login")
+            self.page.wait_for_timeout(3000)
 
             if progress_callback:
                 progress_callback("Please log into Handshake in the browser window, then click 'I'm Logged In' button below.", "login-wait")
@@ -237,21 +168,18 @@ class HandshakeJobApplicator:
 
             # Verify login by checking for jobs page
             try:
-                self.driver.get("https://app.joinhandshake.com/stu/postings")
-                self.driver.fullscreen_window()
-                time.sleep(3)
+                self.page.goto("https://app.joinhandshake.com/stu/postings")
+                self.page.wait_for_timeout(3000)
 
                 # Check if we're on the jobs page
-                self.wait.until(
-                    EC.presence_of_element_located((By.XPATH, "./*"))
-                )
+                self.page.wait_for_selector("body", timeout=20000)
 
                 if progress_callback:
                     progress_callback("Successfully logged into Handshake!", "success")
 
                 return True
 
-            except TimeoutException:
+            except Exception:
                 if progress_callback:
                     progress_callback("Login verification failed. Please ensure you're logged in.", "error")
                 return False
@@ -327,21 +255,12 @@ Return your answer as a JSON array of industry names EXACTLY as they appear in t
 Return ONLY the JSON array with no markdown formatting, nothing else. You must include at least 1 industry."""
 
             try:
-                response = self.claude_client.messages.create(
-                    model="claude-sonnet-4-5-20250929",
-                    max_tokens=300,
-                    messages=[{"role": "user", "content": prompt}]
-                )
-            except anthropic.AuthenticationError as auth_error:
-                print(f"❌ Claude API authentication failed: {str(auth_error)}")
-                raise Exception(f"API authentication error: {str(auth_error)}")
+                response_text = self.llm_client.create_message(prompt, max_tokens=300)
+                response_text = response_text.strip()
             except Exception as api_error:
-                print(f"❌ Claude API error: {str(api_error)}")
+                print(f"❌ LLM API error: {str(api_error)}")
                 raise Exception(f"API error: {str(api_error)}")
 
-            # Parse the response
-            response_text = response.content[0].text.strip()
-
             # Remove markdown code blocks if present
             if response_text.startswith("```"):
                 response_text = response_text.split("```")[1]
@@ -417,25 +336,14 @@ For example:
 Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown, just the string "lat,long"."""
 
             try:
-                response = self.claude_client.messages.create(
-                    model="claude-sonnet-4-5-20250929",
-                    max_tokens=100,
-                    messages=[{"role": "user", "content": prompt}]
-                )
-            except anthropic.AuthenticationError as auth_error:
-                raise ValueError(
-                    f"Claude API authentication failed: {str(auth_error)}\n"
-                    f"Your API key in setup.py may be invalid or expired."
-                )
+                coordinates = self.llm_client.create_message(prompt, max_tokens=100)
+                coordinates = coordinates.strip()
             except Exception as api_error:
                 raise ValueError(
-                    f"Claude API error: {str(api_error)}\n"
+                    f"LLM API error: {str(api_error)}\n"
                     f"Please check your API key and internet connection."
                 )
 
-            # Parse the response - should be just the coordinates string
-            coordinates = response.content[0].text.strip()
-
             # Remove quotes if AI added them
             coordinates = coordinates.replace('"', '').replace("'", "")
 
@@ -557,24 +465,22 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                     progress_callback(f"Navigating to filtered jobs (Industry: {industry}, Location: {location}" +
                                       (f", Role: {role}" if role else "") + ")...", "in-progress")
 
-                self.driver.get(filter_url)
-                self.driver.fullscreen_window()
-                time.sleep(5)
-                currUrl=self.driver.current_url
+                self.page.goto(filter_url)
+                self.page.wait_for_timeout(5000)
+                currUrl = self.page.url
                 if industry:
                     for code in industry_codes:
-                        currUrl+= f'&industries={code}'
+                        currUrl += f'&industries={code}'
 
-                currUrl=currUrl + '&jobType=3'
-                self.driver.get(currUrl)
-                self.driver.fullscreen_window()
-                time.sleep(3)
+                currUrl = currUrl + '&jobType=3'
+                self.page.goto(currUrl)
+                self.page.wait_for_timeout(3000)
                 if(role):
-                    jobTypeField = self.driver.find_element(By.XPATH, "//input[@placeholder='Search jobs']")
-                    jobTypeField.clear()
-                    jobTypeField.send_keys(role)
-                    jobTypeField.send_keys(Keys.ENTER)
-                    time.sleep(4)
+                    jobTypeField = self.page.locator("input[placeholder='Search jobs']")
+                    jobTypeField.fill("")
+                    jobTypeField.fill(role)
+                    jobTypeField.press("Enter")
+                    self.page.wait_for_timeout(4000)
 
                 
                 results["message"] = f"Successfully navigated to filtered jobs page. Filters applied - Industry: {industry}, Location: {location}" + (f", Role: {role}" if role else "")
@@ -588,41 +494,42 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                     progress_callback("Login successful! Ready for job applications (functionality coming soon).", "success")
 
                 
-            print('reached applying to selected jobs')    
-            time.sleep(3)
-            jobsHook = self.driver.find_element(By.CSS_SELECTOR, "[aria-label='Jobs List']")
-            jobsHookElements=jobsHook.find_elements(By.XPATH,"./*")
-            clickableJobLinks=jobsHookElements[2]
-            
-            iterativeJobLinks=clickableJobLinks.find_elements(By.XPATH,"./*")
-            #print(f"Found {len(clickableJobLinks)} elements to click")
-            for index, element in enumerate(iterativeJobLinks):
-                try:
-                    print(f"Index Value: {index}")
-                    jobsHook = self.driver.find_element(By.CSS_SELECTOR, "[aria-label='Jobs List']")
-                    jobsHookElements=jobsHook.find_elements(By.XPATH,"./*")
-                    clickableJobLinks=jobsHookElements[2]
-                    iterativeJobLinks=clickableJobLinks.find_elements(By.XPATH,"./*")
-                    currentJob=iterativeJobLinks[index]
-                    
-                    self.driver.execute_script("arguments[0].scrollIntoView();", currentJob)
-                    currentJob=iterativeJobLinks[index]
-                    print(f"Clicking element {index + 1}...")
-                    print(currentJob.text)
-                    currentJob.click()
-                    
-                    jobName=currentJob.text.split('\n')[0]
-                    
-                    time.sleep(1)
-                    value=self.applyToSelectedJob(jobName,progress_callback)
-                    if not value:
+            print('reached applying to selected jobs')
+            self.page.wait_for_timeout(3000)
+            jobsHook = self.page.locator("[aria-label='Jobs List']")
+            jobsHookElements = jobsHook.locator("> *").all()
+            if len(jobsHookElements) > 2:
+                clickableJobLinks = jobsHookElements[2]
+                iterativeJobLinks = clickableJobLinks.locator("> *").all()
+
+                for index, element in enumerate(iterativeJobLinks):
+                    try:
+                        print(f"Index Value: {index}")
+                        # Re-fetch elements to avoid stale references
+                        jobsHook = self.page.locator("[aria-label='Jobs List']")
+                        jobsHookElements = jobsHook.locator("> *").all()
+                        clickableJobLinks = jobsHookElements[2]
+                        iterativeJobLinks = clickableJobLinks.locator("> *").all()
+                        currentJob = iterativeJobLinks[index]
+
+                        currentJob.scroll_into_view_if_needed()
+                        print(f"Clicking element {index + 1}...")
+                        jobText = currentJob.text_content() or ""
+                        print(jobText)
+                        currentJob.click()
+
+                        jobName = jobText.split('\n')[0]
+
+                        self.page.wait_for_timeout(1000)
+                        value = self.applyToSelectedJob(jobName, progress_callback)
+                        if not value:
+                            continue
+                        else:
+                            results["applications_submitted"] += 1
+                    except Exception as e:
+                        if progress_callback:
+                            progress_callback(f"Could not click element {index + 1}: {e}")
                         continue
-                    else:
-                        results["applications_submitted"] += 1
-                except Exception as e:
-                    if progress_callback:
-                        progress_callback(f"Could not click element {index + 1}: {e}")
-                    continue
         except Exception as e:
             error_msg = f"Session error: {str(e)}"
             print(error_msg)
@@ -631,11 +538,11 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
                 progress_callback(error_msg, "error")
 
         finally:
-            if self.driver is not None:
+            if self.browser_manager is not None:
                 try:
                     print("\nClosing browser in 30 seconds...")
                     time.sleep(30)
-                    self.driver.quit()
+                    self.browser_manager.close()
                     print("Browser closed successfully.")
                 except Exception as e:
                     print(f"Warning: Error closing browser: {str(e)}")
@@ -663,46 +570,45 @@ Return ONLY the coordinates string in quotes, nothing else. No JSON, no markdown
         """
         try:
             # ADD FUNCTIONALITY TO SEE IF APPLY BUTTON IS THE RIGHT ONE. RETURN FALSE IF NOT.
-            applyButton=self.driver.find_element(By.CSS_SELECTOR, "button[class^='sc-hhOBVt']")
-            if applyButton.text=="Apply":
+            applyButton = self.page.locator("button[class^='sc-hhOBVt']").first
+            if applyButton.text_content() == "Apply":
                 print("Correct Apply Button Found")
-            
+
             # Expand job description to get full details
                 print('📋 Extracting job details...')
                 if progress_callback:
                     progress_callback("Extracting job details...", "in-progress")
-                expandJobDescription = self.driver.find_elements(By.CSS_SELECTOR, "button[class^='sc-kAuIVs']")[1]
-                print(expandJobDescription.text)
-                
-                self.driver.execute_script("arguments[0].scrollIntoView();", expandJobDescription)
-                expandJobDescription = self.driver.find_elements(By.CSS_SELECTOR, "button[class^='sc-kAuIVs']")[1]
+                expandJobDescriptionElements = self.page.locator("button[class^='sc-kAuIVs']").all()
+                if len(expandJobDescriptionElements) > 1:
+                    expandJobDescription = expandJobDescriptionElements[1]
+                    print(expandJobDescription.text_content())
 
+                    expandJobDescription.scroll_into_view_if_needed()
+                    expandJobDescription.click()
+                    self.page.wait_for_timeout(2000)
+                    print('✅ Job description expanded')
 
-                expandJobDescription.click()
-                time.sleep(2)
-                print('✅ Job description expanded')
-                
                 try:
-                    job_title_element = self.driver.find_element(By.CSS_SELECTOR, "h1[class^='sc-']")
-                    job_title = job_title_element.text.strip()
+                    job_title_element = self.page.locator("h1[class^='sc-']").first
+                    job_title = (job_title_element.text_content() or "").strip()
                 except:
                     job_title = "Unknown Position"
 
-                #FIX THIS PART
-                company_name=job_name
+                # FIX THIS PART
+                company_name = job_name
 
                 # Extract job description
                 try:
-                    job_description = self.driver.find_element(By.XPATH, "//*[text()='At a glance']/ancestor::div[3]/div[5]/div[1]").text
+                    job_description = self.page.locator("xpath=//*[text()='At a glance']/ancestor::div[3]/div[5]/div[1]").text_content() or ""
                 except:
                     # Fallback: try to get any visible job description
                     try:
-                        job_description = self.driver.find_element(By.CSS_SELECTOR, "[class*='description']").text
+                        job_description = self.page.locator("[class*='description']").first.text_content() or ""
                     except:
                         job_description = "No job description available"
 
                 # Extract job ID from URL
-                current_url = self.driver.current_url
+                current_url = self.page.url
                 job_id = current_url.split('/')[-1].split('?')[0] if '/' in current_url else f"{company_name}_{job_title}_{int(time.time())}"
 
                 print(f'\n✅ Job Details Extracted:')

ResumeGenerator.py

@@ -1,22 +1,21 @@
 """
 Resume Generation Module for ATS Optimization
 
-This module uses Claude API to analyze job descriptions and tailor resumes
-to be ATS-optimized. It generates professional LaTeX resumes using PyLaTeX.
+This module uses OpenRouter API (MiMo v2 Flash) to analyze job descriptions
+and tailor resumes to be ATS-optimized. It generates professional LaTeX resumes.
 """
 
 import os
 import re
 import json
 import shutil
-import anthropic
-import setup
 import subprocess
 from datetime import datetime
 from pathlib import Path
 from pylatex import Document, Section, Subsection, Command, Package
 from pylatex.utils import NoEscape, bold, italic
 from PyPDF2 import PdfReader
+from llm_client import get_client
 
 
 def check_latex_installation():
@@ -57,12 +56,7 @@ class ATSResumeGenerator:
             warn_latex: Whether to warn about missing LaTeX installation
         """
         self.original_resume_path = original_resume_path
-        self.claude_api_key = setup.API_KEY
-
-        if not self.claude_api_key or not self.claude_api_key.startswith('sk-ant-'):
-            raise ValueError("Invalid API key in setup.py")
-
-        self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
+        self.llm_client = get_client()
 
         # Create directories for generated resumes
         self.generated_resumes_dir = os.path.join(os.path.dirname(__file__), "generated_resumes")
@@ -199,14 +193,8 @@ Return ONLY a JSON object with the following structure (no markdown, no code blo
 IMPORTANT: Wrap items to be bolded with **double asterisks** in the bullet points. Include all relevant sections that exist in the original resume. If a section doesn't exist or isn't relevant, include it as an empty array or omit it. Focus on making this resume highly tailored to the {job_title} position at {company_name}."""
 
         try:
-            response = self.claude_client.messages.create(
-                model="claude-sonnet-4-5-20250929",
-                max_tokens=4000,
-                messages=[{"role": "user", "content": prompt}]
-            )
-
-            # Parse response
-            response_text = response.content[0].text.strip()
+            response_text = self.llm_client.create_message(prompt, max_tokens=4000)
+            response_text = response_text.strip()
 
             # Remove markdown code blocks if present
             if response_text.startswith("```"):

browser_utils.py

@@ -0,0 +1,148 @@
+"""
+Browser automation utilities using Playwright.
+Includes anti-detection measures for web automation.
+"""
+from playwright.sync_api import sync_playwright, Page, Browser, Playwright
+
+# Try to import stealth plugin if available
+try:
+    from playwright_stealth import stealth_sync
+    HAS_STEALTH = True
+except ImportError:
+    HAS_STEALTH = False
+
+
+class BrowserManager:
+    """
+    Manages Playwright browser instance with anti-detection measures.
+    """
+
+    def __init__(self, headless=False):
+        self.headless = headless
+        self.playwright: Playwright = None
+        self.browser: Browser = None
+        self.context = None
+        self.page: Page = None
+
+    def setup(self):
+        """Initialize browser with anti-detection measures."""
+        self.playwright = sync_playwright().start()
+
+        # Launch browser with stealth options
+        self.browser = self.playwright.chromium.launch(
+            headless=self.headless,
+            args=[
+                '--no-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-blink-features=AutomationControlled',
+                '--disable-gpu',
+                '--disable-software-rasterizer',
+                '--window-size=1920,1080',
+            ]
+        )
+
+        # Create context with custom user agent
+        self.context = self.browser.new_context(
+            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            viewport={'width': 1920, 'height': 1080},
+            java_script_enabled=True,
+        )
+
+        self.page = self.context.new_page()
+
+        # Apply stealth if available
+        if HAS_STEALTH:
+            stealth_sync(self.page)
+
+        # Remove webdriver property
+        self.page.add_init_script("""
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined
+            });
+        """)
+
+        # Set default timeout (equivalent to WebDriverWait 20 seconds)
+        self.page.set_default_timeout(20000)
+
+        return self.page
+
+    def close(self):
+        """Clean up browser resources."""
+        if self.page:
+            self.page.close()
+        if self.context:
+            self.context.close()
+        if self.browser:
+            self.browser.close()
+        if self.playwright:
+            self.playwright.stop()
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.setup()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+
+def find_element_with_fallback(page: Page, selectors: list, timeout: int = 5000):
+    """
+    Try multiple selectors until one succeeds.
+
+    Args:
+        page: Playwright page object
+        selectors: List of CSS/XPath selectors
+        timeout: Timeout per selector attempt in milliseconds
+
+    Returns:
+        Locator if found, None otherwise
+    """
+    for selector in selectors:
+        try:
+            locator = page.locator(selector)
+            locator.wait_for(timeout=timeout, state='visible')
+            if locator.count() > 0:
+                return locator
+        except Exception:
+            continue
+    return None
+
+
+def scroll_to_bottom(page: Page, max_scrolls: int = 10, wait_time: int = 2000):
+    """
+    Scroll to bottom of page to load dynamic content.
+
+    Args:
+        page: Playwright page object
+        max_scrolls: Maximum number of scroll attempts
+        wait_time: Wait time between scrolls in milliseconds
+    """
+    last_height = page.evaluate("document.body.scrollHeight")
+
+    for _ in range(max_scrolls):
+        page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+        page.wait_for_timeout(wait_time)
+
+        new_height = page.evaluate("document.body.scrollHeight")
+        if new_height == last_height:
+            break
+        last_height = new_height
+
+    # Scroll back to top
+    page.evaluate("window.scrollTo(0, 0)")
+    page.wait_for_timeout(1000)
+
+
+def create_browser(headless=False):
+    """
+    Factory function to create a browser manager.
+
+    Args:
+        headless: Run in headless mode (default: False for debugging)
+
+    Returns:
+        BrowserManager instance
+    """
+    return BrowserManager(headless=headless)

llm_client.py

@@ -0,0 +1,93 @@
+"""
+LLM Client Wrapper for OpenRouter API
+Provides a unified interface for OpenRouter models (MiMo v2 Flash).
+"""
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class LLMClient:
+    """
+    Wrapper class for OpenRouter API using OpenAI SDK format.
+    """
+
+    def __init__(self, api_key=None):
+        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "OPENROUTER_API_KEY not set. "
+                "Please set it in your .env file."
+            )
+
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=self.api_key
+        )
+        self.model = "xiaomi/mimo-v2-flash:free"
+
+    def create_message(self, prompt, max_tokens=4096, system_prompt=None):
+        """
+        Create a message using OpenRouter API.
+
+        Args:
+            prompt: User prompt (string or list of content blocks)
+            max_tokens: Maximum tokens to generate
+            system_prompt: Optional system prompt
+
+        Returns:
+            str: The model's response text
+        """
+        messages = []
+
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        # Handle string prompt or content list
+        if isinstance(prompt, str):
+            messages.append({"role": "user", "content": prompt})
+        elif isinstance(prompt, list):
+            # Convert content blocks to text-only format
+            content_str = self._convert_content_blocks(prompt)
+            messages.append({"role": "user", "content": content_str})
+
+        response = self.client.chat.completions.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            messages=messages
+        )
+
+        return response.choices[0].message.content
+
+    def _convert_content_blocks(self, content_blocks):
+        """
+        Convert content blocks to text-only format.
+        OpenRouter/MiMo doesn't support document attachments.
+        """
+        text_parts = []
+        for block in content_blocks:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text_parts.append(block.get("text", ""))
+            elif isinstance(block, str):
+                text_parts.append(block)
+        return "\n".join(text_parts)
+
+
+# Singleton instance for global use
+_client = None
+
+
+def get_client(api_key=None):
+    """Get or create the LLM client singleton."""
+    global _client
+    if _client is None:
+        _client = LLMClient(api_key)
+    return _client
+
+
+def reset_client():
+    """Reset the singleton client (useful for testing)."""
+    global _client
+    _client = None

pdf_utils.py

@@ -0,0 +1,52 @@
+"""
+PDF Utility functions for text extraction.
+Used to convert PDF resumes to text for LLM processing.
+"""
+from PyPDF2 import PdfReader
+
+
+def extract_text_from_pdf(pdf_path):
+    """
+    Extract text content from a PDF file.
+
+    Args:
+        pdf_path: Path to the PDF file
+
+    Returns:
+        str: Extracted text content
+    """
+    try:
+        reader = PdfReader(pdf_path)
+        text = ""
+        for page in reader.pages:
+            page_text = page.extract_text()
+            if page_text:
+                text += page_text + "\n"
+        return text.strip()
+    except Exception as e:
+        print(f"Error extracting PDF text: {str(e)}")
+        return ""
+
+
+def extract_text_from_pdf_bytes(pdf_bytes):
+    """
+    Extract text content from PDF bytes (for in-memory PDFs).
+
+    Args:
+        pdf_bytes: PDF file content as bytes
+
+    Returns:
+        str: Extracted text content
+    """
+    import io
+    try:
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        text = ""
+        for page in reader.pages:
+            page_text = page.extract_text()
+            if page_text:
+                text += page_text + "\n"
+        return text.strip()
+    except Exception as e:
+        print(f"Error extracting PDF text from bytes: {str(e)}")
+        return ""

requirements.txt

@@ -1,5 +1,5 @@
-# Core AI and API
-anthropic>=0.18.0
+# Core AI and API (OpenRouter with OpenAI SDK)
+openai>=1.0.0
 requests>=2.31.0
 
 # Web Framework and Authentication
@@ -8,9 +8,9 @@ werkzeug>=3.0.0
 flask-login>=0.6.3
 flask-sqlalchemy>=3.1.1
 
-# Browser Automation (Handshake DM feature)
-selenium>=4.15.0
-webdriver-manager>=4.0.1
+# Browser Automation (Playwright for Vercel compatibility)
+playwright>=1.40.0
+playwright-stealth>=1.0.0
 
 # Excel File Processing (for legacy Workflow Company Log)
 pandas>=2.0.0

test_playwright.py

@@ -0,0 +1,98 @@
+"""
+Test script for Playwright browser automation.
+Verifies that Playwright is properly installed and configured.
+"""
+
+from browser_utils import BrowserManager, create_browser
+
+
+def test_playwright():
+    """Test Playwright browser initialization and basic navigation."""
+    print("=" * 60)
+    print("Playwright Browser Test")
+    print("=" * 60)
+
+    manager = None
+    try:
+        print("\n1. Initializing Playwright browser...")
+        manager = create_browser(headless=False)
+        page = manager.setup()
+        print("   ✓ Browser initialized successfully")
+
+        print("\n2. Navigating to Google...")
+        page.goto("https://www.google.com")
+        print(f"   ✓ Successfully navigated to: {page.url}")
+        print(f"   ✓ Page title: {page.title()}")
+
+        print("\n3. Testing page interaction...")
+        # Wait for search input
+        search_input = page.locator("textarea[name='q'], input[name='q']").first
+        if search_input.is_visible():
+            print("   ✓ Found search input")
+
+        print("\n4. Browser info:")
+        # Get browser version from context
+        browser_version = page.context.browser.version
+        print(f"   ✓ Browser version: {browser_version}")
+
+        print("\n" + "=" * 60)
+        print("All tests passed! Playwright is working correctly.")
+        print("=" * 60)
+
+        print("\nClosing browser in 5 seconds...")
+        page.wait_for_timeout(5000)
+
+    except Exception as e:
+        print(f"\n✗ Test failed with error: {str(e)}")
+        print("\nTroubleshooting steps:")
+        print("1. Run: pip install playwright")
+        print("2. Run: playwright install chromium")
+        print("3. Make sure no other browser instances are blocking")
+        raise
+
+    finally:
+        if manager:
+            manager.close()
+            print("Browser closed successfully.")
+
+
+def test_llm_client():
+    """Test OpenRouter LLM client."""
+    print("\n" + "=" * 60)
+    print("OpenRouter LLM Client Test")
+    print("=" * 60)
+
+    try:
+        from llm_client import get_client
+
+        print("\n1. Initializing LLM client...")
+        client = get_client()
+        print("   ✓ Client initialized successfully")
+        print(f"   ✓ Model: {client.model}")
+
+        print("\n2. Testing API call...")
+        response = client.create_message("Say 'Hello, World!' and nothing else.", max_tokens=50)
+        print(f"   ✓ Response: {response}")
+
+        print("\n" + "=" * 60)
+        print("LLM client test passed!")
+        print("=" * 60)
+
+    except Exception as e:
+        print(f"\n✗ LLM test failed with error: {str(e)}")
+        print("\nTroubleshooting steps:")
+        print("1. Check your .env file has OPENROUTER_API_KEY set")
+        print("2. Verify your API key is valid at https://openrouter.ai")
+        raise
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--llm":
+        test_llm_client()
+    elif len(sys.argv) > 1 and sys.argv[1] == "--all":
+        test_playwright()
+        test_llm_client()
+    else:
+        test_playwright()