feat: add login command with LeetCode session authentication

Author: yuvrajsinh5252

requirements.txt

@@ -1,4 +1,6 @@
 typer
 requests
 gql[all]
-setuptools
+bs4
+setuptools
+python-leetcode

src/__init__.py

@@ -1,7 +1,6 @@
 from .commands.show import show
 from .commands.details import details
 from .server.api import fetch_problem_list
-
 __version__ = "0.1.0"
 
 __all__ = ["show", "details", "fetch_problem_list"]

src/commands/login.py

@@ -0,0 +1,28 @@
+import typer
+from src.server.auth import Auth
+
+auth_manager = Auth()
+
+def login():
+    """Login to LeetCode"""
+    # First try to use saved session
+    if auth_manager.is_authenticated:
+        saved_session = auth_manager.session_manager.load_session()
+        if saved_session:
+            typer.echo(typer.style(f"Already logged in as {saved_session['user_name']}!", fg=typer.colors.GREEN))
+            return
+
+    typer.echo(typer.style("To login, you'll need your LEETCODE_SESSION token:", fg=typer.colors.YELLOW))
+    typer.echo("\n1. Open LeetCode in your browser")
+    typer.echo("2. Press F12 to open Developer Tools")
+    typer.echo("3. Go to Application tab > Cookies > leetcode.com")
+    typer.echo("4. Find and copy the 'LEETCODE_SESSION' value\n")
+
+    leetcode_session = typer.prompt("Please enter your LEETCODE_SESSION token")
+
+    result = auth_manager.login_with_session(leetcode_session)
+
+    if result["success"]:
+        typer.echo(typer.style(f"\n✓ Successfully logged in as {result['user_name']}!", fg=typer.colors.GREEN))
+    else:
+        typer.echo(typer.style(f"\n✗ Login failed: {result['message']}", fg=typer.colors.RED))

src/main.py

@@ -1,10 +1,12 @@
 import typer
 from src import show, details
+from src.commands.login import login
 
 app = typer.Typer()
 
-app.command()(show)
-app.command()(details)
+app.command(name="show")(show)
+app.command(name="user-details")(details)
+app.command(name="login")(login)
 
 if __name__ == "__main__":
     app()

src/server/auth.py

@@ -0,0 +1,67 @@
+from typing import Dict
+import requests
+from .session_manager import SessionManager
+
+class Auth:
+    def __init__(self):
+        self.session = requests.Session()
+        self.BASE_URL = "https://leetcode.com"
+        self.is_authenticated = False
+        self.session_manager = SessionManager()
+        self._load_saved_session()
+
+    def _load_saved_session(self):
+        """Try to load and validate saved session"""
+        saved_session = self.session_manager.load_session()
+        if saved_session:
+            result = self.login_with_session(saved_session['session_token'])
+            return result["success"]
+        return False
+
+    def login_with_session(self, leetcode_session: str) -> Dict[str, any]: # type: ignore
+        """
+        Login to LeetCode using LEETCODE_SESSION token.
+        Returns a dictionary with success status and message.
+        """
+        try:
+            self.session.cookies.set('LEETCODE_SESSION', leetcode_session, domain='leetcode.com')
+
+            response = self.session.get(
+                f"{self.BASE_URL}/api/problems/all/",
+                headers={
+                    'Accept': 'application/json',
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+            )
+
+            if response.status_code == 200:
+                user_data = response.json()
+                if user_data.get('user_name'):
+                    self.is_authenticated = True
+                    # Save the valid session
+                    self.session_manager.save_session(leetcode_session, user_data['user_name'])
+                    return {
+                        "success": True,
+                        "message": "Successfully logged in",
+                        "user_name": user_data['user_name']
+                    }
+                else:
+                    self.session_manager.clear_session()
+                    return {
+                        "success": False,
+                        "message": "Invalid session token"
+                    }
+            else:
+                self.session_manager.clear_session()
+                return {
+                    "success": False,
+                    "message": f"Login failed with status code: {response.status_code}"
+                }
+
+        except Exception as e:
+            self.session_manager.clear_session()
+            return {"success": False, "message": f"Login error: {str(e)}"}
+
+    def get_session(self) -> requests.Session:
+        """Return the authenticated session."""
+        return self.session

src/server/session_manager.py

@@ -0,0 +1,39 @@
+import json
+import os
+from pathlib import Path
+from typing import Optional, Dict
+
+class SessionManager:
+    def __init__(self):
+        # Create config directory in user's home directory
+        self.config_dir = Path.home() / '.leetcode-cli'
+        self.config_file = self.config_dir / 'session.json'
+        self._ensure_config_dir()
+
+    def _ensure_config_dir(self):
+        """Ensure the config directory exists"""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def save_session(self, session_token: str, user_name: str):
+        """Save the session token and username to file"""
+        data = {
+            'session_token': session_token,
+            'user_name': user_name
+        }
+        with open(self.config_file, 'w') as f:
+            json.dump(data, f)
+
+    def load_session(self) -> Optional[Dict[str, str]]:
+        """Load the session token and username from file"""
+        try:
+            if self.config_file.exists():
+                with open(self.config_file, 'r') as f:
+                    return json.load(f)
+        except Exception:
+            pass
+        return None
+
+    def clear_session(self):
+        """Clear the stored session"""
+        if self.config_file.exists():
+            self.config_file.unlink()