Add fast-linkedin-scraper support with scraper adapter pattern

- Add scraper_factory.py for backend selection between linkedin-scraper and fast-linkedin-scraper
- Add scraper_adapter.py with unified interface for both scrapers
- Add playwright_wrapper.py for Playwright session management (used by fast scraper)
- Update configuration to support scraper_type selection
- Update all tools (person, company, job) to use scraper adapter
- Fix type checking issues in config loaders and playwright wrapper
- Maintain backward compatibility with existing linkedin-scraper backend

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: qosha1

debug_fast_scraper.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Debug script to test fast-linkedin-scraper directly without our wrapper.
+"""
+
+import threading
+
+
+def test_fast_scraper_direct():
+    """Test fast-linkedin-scraper directly."""
+    print("Testing fast-linkedin-scraper directly...")
+
+    try:
+        from fast_linkedin_scraper import LinkedInSession
+
+        print("✅ fast-linkedin-scraper imported successfully")
+
+        # Test getting version info
+        try:
+            import fast_linkedin_scraper
+
+            print(
+                f"📦 fast-linkedin-scraper version: {getattr(fast_linkedin_scraper, '__version__', 'unknown')}"
+            )
+        except Exception:
+            print("📦 Version info not available")
+    except ImportError as e:
+        print(f"❌ Cannot import fast-linkedin-scraper: {e}")
+        return False
+
+    # Test with a dummy cookie to see if the library initializes properly
+    dummy_cookie = "li_at=dummy_cookie_for_testing"
+
+    try:
+        print("🔍 Testing LinkedInSession creation...")
+        with LinkedInSession.from_cookie(dummy_cookie) as session:
+            print(f"✅ Session created successfully: {type(session)}")
+            print(
+                "This would normally fail with invalid cookie, but creation succeeded"
+            )
+
+    except Exception as e:
+        error_msg = str(e).lower()
+        print(f"❌ Session creation failed: {e}")
+
+        if (
+            "'playwrightcontextmanager' object has no attribute '_connection'"
+            in error_msg
+        ):
+            print("🐛 This is the _connection attribute error!")
+            return False
+        elif "invalid" in error_msg and "cookie" in error_msg:
+            print(
+                "✅ Failed due to invalid cookie (expected), but no _connection error!"
+            )
+            return True
+        else:
+            print(f"❓ Unknown error: {error_msg}")
+            return False
+
+    return True
+
+
+def test_in_thread():
+    """Test fast-linkedin-scraper in a separate thread."""
+    print("\n" + "=" * 50)
+    print("Testing fast-linkedin-scraper in a separate thread...")
+
+    result_container = {}
+
+    def thread_target():
+        try:
+            result_container["result"] = test_fast_scraper_direct()
+        except Exception as e:
+            result_container["error"] = e
+
+    thread = threading.Thread(target=thread_target)
+    thread.start()
+    thread.join()
+
+    if "error" in result_container:
+        print(f"❌ Thread test failed: {result_container['error']}")
+        return False
+
+    return result_container.get("result", False)
+
+
+if __name__ == "__main__":
+    print("🚀 Fast-LinkedIn-Scraper Debug Test\n")
+
+    # Test 1: Direct execution
+    print("=" * 50)
+    direct_result = test_fast_scraper_direct()
+
+    # Test 2: In thread (simulates our async fix)
+    thread_result = test_in_thread()
+
+    print("\n" + "=" * 50)
+    print("📊 RESULTS:")
+    print(f"Direct test: {'✅ PASSED' if direct_result else '❌ FAILED'}")
+    print(f"Thread test: {'✅ PASSED' if thread_result else '❌ FAILED'}")
+
+    if direct_result and thread_result:
+        print("\n🎉 fast-linkedin-scraper works correctly!")
+    else:
+        print("\n💥 fast-linkedin-scraper has compatibility issues!")
+        print("📋 Recommendations:")
+        print("   1. Check fast-linkedin-scraper installation")
+        print("   2. Ensure playwright is installed: playwright install")
+        print(
+            "   3. Try upgrading: pip install --upgrade fast-linkedin-scraper playwright"
+        )

linkedin_mcp_server/authentication.py

@@ -87,7 +87,7 @@ def clear_authentication() -> bool:
 
 def ensure_authentication() -> str:
     """
-    Ensure authentication is available with clear error messages.
+    Ensure authentication is available with backend-aware error messages.
 
     Returns:
         str: Valid LinkedIn session cookie
@@ -100,6 +100,16 @@ def ensure_authentication() -> str:
     except CredentialsNotFoundError:
         config = get_config()
 
-        raise CredentialsNotFoundError(
-            ErrorMessages.no_cookie_found(config.is_interactive)
-        )
+        # Provide backend-specific guidance
+        if config.linkedin.scraper_type == "fast-linkedin-scraper":
+            error_msg = (
+                f"No LinkedIn cookie found for {config.linkedin.scraper_type}. "
+                "This scraper requires a valid LinkedIn session cookie. You can:\n"
+                "  1. Set LINKEDIN_COOKIE environment variable with a valid LinkedIn session cookie\n"
+                "  2. Use --cookie flag to provide the cookie directly\n"
+                "  3. Run with linkedin-scraper first using --get-cookie to extract a cookie"
+            )
+        else:
+            error_msg = ErrorMessages.no_cookie_found(config.is_interactive)
+
+        raise CredentialsNotFoundError(error_msg)

linkedin_mcp_server/cli_main.py

@@ -31,10 +31,16 @@
     get_config,
     get_keyring_name,
 )
-from linkedin_mcp_server.drivers.chrome import close_all_drivers, get_or_create_driver
+
+# Chrome driver imports are now handled by the scraper factory
 from linkedin_mcp_server.exceptions import CredentialsNotFoundError, LinkedInMCPError
 from linkedin_mcp_server.logging_config import configure_logging
 from linkedin_mcp_server.server import create_mcp_server, shutdown_handler
+from linkedin_mcp_server.scraper_factory import (
+    cleanup_scraper_backend,
+    get_backend_capabilities,
+    initialize_scraper_backend,
+)
 from linkedin_mcp_server.setup import run_cookie_extraction_setup, run_interactive_setup
 
 sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
@@ -242,33 +248,38 @@ def ensure_authentication_ready() -> str:
     return run_interactive_setup()
 
 
-def initialize_driver_with_auth(authentication: str) -> None:
+def initialize_backend_with_auth(authentication: str) -> None:
     """
-    Phase 2: Initialize driver using existing authentication.
+    Phase 2: Initialize scraper backend using existing authentication.
 
     Args:
-        authentication: LinkedIn session cookie
+        authentication: LinkedIn session cookie (not used directly, backends get auth via ensure_authentication())
 
     Raises:
-        Various exceptions if driver creation or login fails
+        Various exceptions if backend initialization fails
     """
     config = get_config()
 
     if config.server.lazy_init:
+        backend_info = get_backend_capabilities()
         logger.info(
-            "Using lazy initialization - driver will be created on first tool call"
+            f"Using lazy initialization - {backend_info['backend']} will be created on first tool call"
         )
         return
 
-    logger.info("Initializing Chrome WebDriver and logging in...")
+    backend_info = get_backend_capabilities()
+    logger.info(f"Initializing {backend_info['backend']} backend...")
 
     try:
-        # Create driver and login with provided authentication
-        get_or_create_driver(authentication)
-        logger.info("✅ Web driver initialized and authenticated successfully")
+        # Initialize the appropriate backend (authentication is handled internally)
+        success = initialize_scraper_backend()
+        if success:
+            logger.info("✅ Scraper backend initialized and authenticated successfully")
+        else:
+            raise Exception("Backend initialization returned False")
 
     except Exception as e:
-        logger.error(f"Failed to initialize driver: {e}")
+        logger.error(f"Failed to initialize scraper backend: {e}")
         raise e
 
 
@@ -345,21 +356,21 @@ def main() -> None:
         print("\n❌ Setup failed - please try again")
         sys.exit(1)
 
-    # Phase 2: Initialize Driver (if not lazy)
+    # Phase 2: Initialize Backend (if not lazy)
     try:
-        initialize_driver_with_auth(authentication)
+        initialize_backend_with_auth(authentication)
     except InvalidCredentialsError as e:
-        logger.error(f"Driver initialization failed with invalid credentials: {e}")
+        logger.error(f"Backend initialization failed with invalid credentials: {e}")
 
-        # Cookie was already cleared in driver layer
+        # Cookie was already cleared in authentication layer
         # In interactive mode, try setup again
         if config.is_interactive:
             print(f"\n❌ {str(e)}")
             print("🔄 Starting interactive setup for new authentication...")
             try:
                 new_authentication = run_interactive_setup()
                 # Try again with new authentication
-                initialize_driver_with_auth(new_authentication)
+                initialize_backend_with_auth(new_authentication)
                 logger.info("✅ Successfully authenticated with new credentials")
             except Exception as setup_error:
                 logger.error(f"Setup failed: {setup_error}")
@@ -377,13 +388,13 @@ def main() -> None:
         RateLimitError,
         LoginTimeoutError,
     ) as e:
-        logger.error(f"Driver initialization failed: {e}")
+        logger.error(f"Backend initialization failed: {e}")
         print(f"\n❌ {str(e)}")
         if not config.server.lazy_init:
             sys.exit(1)
     except Exception as e:
-        logger.error(f"Unexpected error during driver initialization: {e}")
-        print(f"\n❌ Driver initialization failed: {e}")
+        logger.error(f"Unexpected error during backend initialization: {e}")
+        print(f"\n❌ Backend initialization failed: {e}")
         if not config.server.lazy_init:
             sys.exit(1)
 
@@ -437,8 +448,8 @@ def exit_gracefully(exit_code: int = 0) -> None:
     """Exit the application gracefully, cleaning up resources."""
     print("👋 Shutting down LinkedIn MCP server...")
 
-    # Clean up drivers
-    close_all_drivers()
+    # Clean up scraper backend
+    cleanup_scraper_backend()
 
     # Clean up server
     shutdown_handler()