perplexity-web-mcp-cli 0.14.2__tar.gz → 0.14.4__tar.gz

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perplexity-web-mcp-cli
-Version: 0.14.2
+Version: 0.14.4
 Summary: CLI, MCP server, and Anthropic/OpenAI API-compatible interface for Perplexity AI.
 Keywords: perplexity,ai,mcp,anthropic,api,client
 Author: Jacob BD
@@ -22,6 +22,7 @@ Requires-Dist: loguru>=0.7.3,<1.0
 Requires-Dist: orjson>=3.11.6,<4.0
 Requires-Dist: pydantic>=2.12.5,<3.0
 Requires-Dist: tenacity>=9.1.2,<10.0
+Requires-Dist: tomli>=2.0.0,<3.0 ; python_full_version < '3.11'
 Requires-Dist: python-dotenv>=1.0.0,<2.0
 Requires-Dist: rich>=13.0.0,<15.0
 Requires-Dist: rich-click>=1.8
@@ -269,8 +270,12 @@ pwm login                                    # Interactive login (email + OTP)
 pwm login --check                            # Check if authenticated
 pwm login --email user@example.com           # Send verification code (non-interactive)
 pwm login --email user@example.com --code 123456  # Complete auth with code
+pwm login --email user@example.com --code 123456 --totp-code 654321  # Account with TOTP enabled
 ```
 
+Set `PWM_SAVE_TO_LIBRARY=1` to save shared CLI and MCP queries to the Perplexity thread library. Queries are
+incognito by default.
+
 ### Usage & Limits
 
 ```bash
@@ -455,7 +460,7 @@ claude mcp add perplexity pwm-mcp
 | `pplx_connectors`        | List connector source IDs       |
 | `pplx_auth_status`       | Check authentication status     |
 | `pplx_auth_request_code` | Send verification code to email |
-| `pplx_auth_complete`     | Complete auth with 6-digit code |
+| `pplx_auth_complete`     | Complete email and TOTP authentication |
 
 All query tools support `source_focus`: `none`, `web`, `academic`, `social`, `finance`, `all`, or a connector source ID returned by `pplx_connectors()`.
 
@@ -586,6 +591,9 @@ pwm login --email your@email.com --code 123456
 2. Check email for 6-digit code
 3. Call `pplx_auth_complete(email="your@email.com", code="123456")`
 
+If the tool returns `TOTP_REQUIRED`, call it again with
+`pplx_auth_complete(email="your@email.com", totp_code="654321")`.
+
 ### Diagnose Issues
 
 ```bash

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/README.md

@@ -232,8 +232,12 @@ pwm login                                    # Interactive login (email + OTP)
 pwm login --check                            # Check if authenticated
 pwm login --email user@example.com           # Send verification code (non-interactive)
 pwm login --email user@example.com --code 123456  # Complete auth with code
+pwm login --email user@example.com --code 123456 --totp-code 654321  # Account with TOTP enabled
 ```
 
+Set `PWM_SAVE_TO_LIBRARY=1` to save shared CLI and MCP queries to the Perplexity thread library. Queries are
+incognito by default.
+
 ### Usage & Limits
 
 ```bash
@@ -418,7 +422,7 @@ claude mcp add perplexity pwm-mcp
 | `pplx_connectors`        | List connector source IDs       |
 | `pplx_auth_status`       | Check authentication status     |
 | `pplx_auth_request_code` | Send verification code to email |
-| `pplx_auth_complete`     | Complete auth with 6-digit code |
+| `pplx_auth_complete`     | Complete email and TOTP authentication |
 
 All query tools support `source_focus`: `none`, `web`, `academic`, `social`, `finance`, `all`, or a connector source ID returned by `pplx_connectors()`.
 
@@ -549,6 +553,9 @@ pwm login --email your@email.com --code 123456
 2. Check email for 6-digit code
 3. Call `pplx_auth_complete(email="your@email.com", code="123456")`
 
+If the tool returns `TOTP_REQUIRED`, call it again with
+`pplx_auth_complete(email="your@email.com", totp_code="654321")`.
+
 ### Diagnose Issues
 
 ```bash

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "perplexity-web-mcp-cli"
-version = "0.14.2"
+version = "0.14.4"
 description = "CLI, MCP server, and Anthropic/OpenAI API-compatible interface for Perplexity AI."
 authors = [{ name = "Jacob BD" }]
 license = "MIT"
@@ -27,6 +27,7 @@ dependencies = [
     "orjson>=3.11.6,<4.0",
     "pydantic>=2.12.5,<3.0",
     "tenacity>=9.1.2,<10.0",
+    "tomli>=2.0.0,<3.0; python_version < '3.11'",
     "python-dotenv>=1.0.0,<2.0",
     "rich>=13.0.0,<15.0",
     "rich-click>=1.8",

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/api/server.py

@@ -1075,8 +1075,8 @@ async def stream_response(
 
         elif kind == "error":
             logging.error(f"Stream error: {payload}")
-            # Add recovery instructions for 403 errors
-            error_msg = payload
+            # Strip wrapper prefixes for cleaner client-facing messages
+            error_msg = payload.removeprefix("Failed to parse API response: ")
             if "403" in payload or "forbidden" in payload.lower():
                 error_msg = (
                     "Session token expired (403). "

perplexity_web_mcp_cli-0.14.4/src/perplexity_web_mcp/auth.py

@@ -0,0 +1,153 @@
+"""Perplexity email and TOTP authentication protocol helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from curl_cffi.requests import Session
+
+from .constants import API_BASE_URL, API_VERSION, APP_HEADERS, SESSION_COOKIE_NAME
+
+
+AUTH_CSRF_ENDPOINT = "/api/auth/csrf"
+AUTH_OTP_REDIRECT_ENDPOINT = "/api/auth/otp-redirect-link"
+AUTH_SIGNIN_ENDPOINT = "/api/auth/signin/email"
+AUTH_TOTP_VERIFY_ENDPOINT = "/api/auth/totp-challenge/verify"
+_REDIRECT_STATUSES = {301, 302, 303, 307, 308}
+
+
+def create_auth_session() -> tuple[Session, str]:
+    """Create a browser-like session and return it with a CSRF token."""
+    session = Session(
+        impersonate="chrome",
+        headers={**APP_HEADERS, "Referer": API_BASE_URL, "Origin": API_BASE_URL},
+    )
+    session.get(API_BASE_URL)
+    response = session.get(f"{API_BASE_URL}{AUTH_CSRF_ENDPOINT}")
+
+    if response.status_code != 200:
+        raise ValueError(f"Failed to obtain CSRF token: HTTP {response.status_code}.")
+
+    csrf = _response_json(response).get("csrfToken")
+    if not csrf:
+        raise ValueError("Failed to obtain CSRF token.")
+
+    return session, str(csrf)
+
+
+def request_verification_code(session: Session, csrf: str, email: str) -> None:
+    """Send an email verification code using an initialized auth session."""
+    response = session.post(
+        f"{API_BASE_URL}{AUTH_SIGNIN_ENDPOINT}?version={API_VERSION}&source=default",
+        json={
+            "email": email,
+            "csrfToken": csrf,
+            "useNumericOtp": "true",
+            "json": "true",
+            "callbackUrl": f"{API_BASE_URL}/?login-source=floatingSignup",
+        },
+    )
+
+    if response.status_code != 200:
+        raise ValueError(f"Authentication request failed: {response.text}")
+
+
+def resolve_redirect_url(session: Session, email: str, code_or_link: str) -> str:
+    """Resolve an email OTP or magic link to the authentication callback URL."""
+    if code_or_link.startswith("http"):
+        return code_or_link
+
+    response = session.post(
+        f"{API_BASE_URL}{AUTH_OTP_REDIRECT_ENDPOINT}",
+        json={
+            "email": email,
+            "otp": code_or_link,
+            "redirectUrl": f"{API_BASE_URL}/?login-source=floatingSignup",
+            "emailLoginMethod": "web-otp",
+        },
+    )
+
+    if response.status_code != 200:
+        raise ValueError("Invalid verification code.")
+
+    redirect_path = _response_json(response).get("redirect")
+    if not redirect_path:
+        raise ValueError("No redirect URL received.")
+
+    redirect = str(redirect_path)
+    return f"{API_BASE_URL}{redirect}" if redirect.startswith("/") else redirect
+
+
+def follow_auth_callback(session: Session, redirect_url: str) -> str | None:
+    """Follow an auth callback, returning a challenge token when TOTP is required."""
+    response = session.get(redirect_url, allow_redirects=False)
+    if response.status_code not in _REDIRECT_STATUSES:
+        return None
+
+    location = response.headers.get("Location", "")
+    if not location:
+        raise ValueError("Authentication callback did not provide a redirect location.")
+    if "error=" in location:
+        raise ValueError("Verification failed. The code may be invalid or expired.")
+
+    if "/auth/totp-challenge" in location:
+        absolute_location = location if location.startswith("http") else f"{API_BASE_URL}{location}"
+        challenge_token = parse_qs(urlparse(absolute_location).query).get("token", [""])[0]
+        if not challenge_token:
+            raise ValueError("TOTP challenge token not found in redirect.")
+        return challenge_token
+
+    session.get(location if location.startswith("http") else f"{API_BASE_URL}{location}")
+    return None
+
+
+def verify_totp(session: Session, challenge_token: str, totp_code: str) -> None:
+    """Complete a TOTP challenge and follow its post-verification redirect."""
+    if not totp_code.isdigit() or len(totp_code) != 6:
+        raise ValueError("TOTP code must be a 6-digit number.")
+
+    response = session.post(
+        f"{API_BASE_URL}{AUTH_TOTP_VERIFY_ENDPOINT}?version={API_VERSION}&source=default",
+        json={"token": challenge_token, "code": totp_code},
+        allow_redirects=False,
+    )
+    data = _response_json(response)
+
+    if response.status_code >= 400 or data.get("error"):
+        detail = data.get("error") or f"HTTP {response.status_code}"
+        raise ValueError(f"TOTP verification failed: {detail}")
+
+    location = response.headers.get("Location", "") if response.status_code in _REDIRECT_STATUSES else ""
+    redirect = location or str(data.get("redirect", ""))
+    if redirect:
+        session.get(redirect if redirect.startswith("http") else f"{API_BASE_URL}{redirect}")
+
+
+def extract_session_token(session: Session) -> str:
+    """Return the session token, including a token split across cookie chunks."""
+    token = session.cookies.get(SESSION_COOKIE_NAME)
+    if token:
+        return token
+
+    chunks = sorted(
+        [
+            (name, value)
+            for name, value in session.cookies.items()
+            if name.startswith(f"{SESSION_COOKIE_NAME}.") and name.removeprefix(f"{SESSION_COOKIE_NAME}.").isdigit()
+        ],
+        key=lambda item: int(item[0].removeprefix(f"{SESSION_COOKIE_NAME}.")),
+    )
+    if chunks:
+        return "".join(value for _, value in chunks)
+
+    raise ValueError("Authentication completed, but the session token cookie was not returned.")
+
+
+def _response_json(response: Any) -> dict[str, Any]:
+    """Return a JSON object from a response, or an empty object for non-JSON bodies."""
+    try:
+        data = response.json()
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/cli/ai_doc.py

@@ -240,8 +240,8 @@ AUTH TOOLS (3):
   pplx_auth_request_code(email)
       Send 6-digit verification code to email.
 
-  pplx_auth_complete(email, code)
-      Complete auth with code from email. Saves token automatically.
+  pplx_auth_complete(email, code, totp_code=None)
+      Complete email OTP and optional TOTP authentication. Saves token automatically.
 
 ================================================================================
 AUTHENTICATION
@@ -255,10 +255,13 @@ Three ways to authenticate (all store token at ~/.config/perplexity-web-mcp/toke
 2. NON-INTERACTIVE CLI (AI agent with shell access):
    pwm login --email user@example.com          # Sends code
    pwm login --email user@example.com --code 123456  # Completes auth
+   pwm login --email user@example.com --code 123456 --totp-code 654321  # TOTP account
 
 3. MCP TOOLS (AI agent without shell):
    pplx_auth_request_code(email="user@example.com")  # Sends code
-   pplx_auth_complete(email="user@example.com", code="123456")  # Completes
+   pplx_auth_complete(email="user@example.com", code="123456")  # Completes email OTP
+   # If TOTP_REQUIRED is returned:
+   pplx_auth_complete(email="user@example.com", totp_code="654321")
 
 Tokens last ~30 days. Re-authenticate when you get 403 errors.
 Check status: pwm login --check  OR  pplx_auth_status()

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/cli/auth.py

@@ -8,18 +8,25 @@ from sys import exit
 from typing import NoReturn
 
 from curl_cffi.requests import Session
-from orjson import loads
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
 
+from perplexity_web_mcp.auth import (
+    create_auth_session,
+    extract_session_token,
+    follow_auth_callback,
+    request_verification_code,
+    resolve_redirect_url,
+    verify_totp,
+)
+from perplexity_web_mcp.constants import API_BASE_URL, APP_HEADERS, SESSION_COOKIE_NAME
 from perplexity_web_mcp.token_store import load_token
 from perplexity_web_mcp.token_store import save_token as save_token_to_config
 
 
-BASE_URL: str = "https://www.perplexity.ai"
-SESSION_COOKIE_NAME: str = "__Secure-next-auth.session-token"
+BASE_URL: str = API_BASE_URL
 
 console = Console(stderr=True, soft_wrap=True)
 
@@ -96,7 +103,7 @@ def get_user_info(token: str) -> UserInfo | None:
     try:
         with Session(
             impersonate="chrome",
-            headers={"Referer": BASE_URL, "Origin": BASE_URL},
+            headers={**APP_HEADERS, "Referer": BASE_URL, "Origin": BASE_URL},
             cookies={SESSION_COOKIE_NAME: token},
         ) as session:
             response = session.get(f"{BASE_URL}/api/user")
@@ -110,77 +117,45 @@ def get_user_info(token: str) -> UserInfo | None:
 
 def _initialize_session() -> tuple[Session, str]:
     """Initialize session and obtain CSRF token."""
-
-    session = Session(impersonate="chrome", headers={"Referer": BASE_URL, "Origin": BASE_URL})
-
     with console.status("[bold green]Initializing secure connection...", spinner="dots"):
-        session.get(BASE_URL)
-        csrf_data = loads(session.get(f"{BASE_URL}/api/auth/csrf").content)
-        csrf = csrf_data.get("csrfToken")
-
-        if not csrf:
-            raise ValueError("Failed to obtain CSRF token.")
-
-    return session, csrf
+        return create_auth_session()
 
 
 def _request_verification_code(session: Session, csrf: str, email: str) -> None:
     """Send verification code to user's email."""
-
     with console.status("[bold green]Sending verification code...", spinner="dots"):
-        response = session.post(
-            f"{BASE_URL}/api/auth/signin/email?version=2.18&source=default",
-            json={
-                "email": email,
-                "csrfToken": csrf,
-                "useNumericOtp": "true",
-                "json": "true",
-                "callbackUrl": f"{BASE_URL}/?login-source=floatingSignup",
-            },
-        )
-
-        if response.status_code != 200:
-            raise ValueError(f"Authentication request failed: {response.text}")
+        request_verification_code(session, csrf, email)
 
 
 def _validate_and_get_redirect_url(session: Session, email: str, user_input: str) -> str:
     """Validate user input (OTP or magic link) and return redirect URL."""
-
     with console.status("[bold green]Validating...", spinner="dots"):
-        if user_input.startswith("http"):
-            return user_input
-
-        response_otp = session.post(
-            f"{BASE_URL}/api/auth/otp-redirect-link",
-            json={
-                "email": email,
-                "otp": user_input,
-                "redirectUrl": f"{BASE_URL}/?login-source=floatingSignup",
-                "emailLoginMethod": "web-otp",
-            },
-        )
-
-        if response_otp.status_code != 200:
-            raise ValueError("Invalid verification code.")
-
-        redirect_path = loads(response_otp.content).get("redirect")
-
-        if not redirect_path:
-            raise ValueError("No redirect URL received.")
+        return resolve_redirect_url(session, email, user_input)
 
-        return f"{BASE_URL}{redirect_path}" if redirect_path.startswith("/") else redirect_path
 
+def _complete_auth_callback(session: Session, redirect_url: str, totp_code: str | None = None) -> str:
+    """Complete the callback and optional TOTP challenge, then return the session token."""
+    challenge_token = follow_auth_callback(session, redirect_url)
+    if challenge_token:
+        if not totp_code:
+            raise ValueError("TOTP is required. Re-run with --totp-code and the code from your authenticator app.")
+        verify_totp(session, challenge_token, totp_code)
+    return extract_session_token(session)
 
-def _extract_session_token(session: Session, redirect_url: str) -> str:
-    """Extract session token from cookies after authentication."""
 
-    session.get(redirect_url)
-    token = session.cookies.get(SESSION_COOKIE_NAME)
+def _prompt_and_verify_totp(session: Session, challenge_token: str) -> None:
+    """Prompt until a valid TOTP code completes the challenge."""
+    console.print("\n[bold cyan]Step 3: Two-Factor Authentication[/bold cyan]")
+    console.print("  Enter the 6-digit code from your authenticator app.")
 
-    if not token:
-        raise ValueError("Authentication successful, but token not found.")
-
-    return token
+    while True:
+        totp_code = Prompt.ask("  Enter TOTP code", console=console).strip()
+        try:
+            with console.status("[bold green]Verifying TOTP...", spinner="dots"):
+                verify_totp(session, challenge_token, totp_code)
+            return
+        except ValueError as error:
+            console.print(f"[red]  {error}[/red]")
 
 
 def _display_user_info(user_info: UserInfo) -> None:
@@ -245,13 +220,19 @@ def _show_exit_message() -> None:
     console.input()
 
 
-def auth_non_interactive(email: str, code: str | None = None, auto_save: bool = True) -> str | None:
+def auth_non_interactive(
+    email: str,
+    code: str | None = None,
+    auto_save: bool = True,
+    totp_code: str | None = None,
+) -> str | None:
     """Non-interactive authentication for AI agents.
 
     Args:
         email: Perplexity account email
         code: 6-digit verification code (if None, sends code and returns None)
         auto_save: Whether to automatically save token to config
+        totp_code: Optional 6-digit authenticator code for accounts with TOTP enabled
 
     Returns:
         Session token if code provided, None if code was sent
@@ -275,7 +256,7 @@ def auth_non_interactive(email: str, code: str | None = None, auto_save: bool =
 
         # Step 2: Complete authentication
         redirect_url = _validate_and_get_redirect_url(session, email, code)
-        token = _extract_session_token(session, redirect_url)
+        token = _complete_auth_callback(session, redirect_url, totp_code)
 
         # Verify token works
         user_info = get_user_info(token)
@@ -318,6 +299,7 @@ def main() -> NoReturn:
                 "  --check          Check if authenticated without logging in\n"
                 "  --email EMAIL    Email address for non-interactive auth\n"
                 "  --code CODE      6-digit verification code from email\n"
+                "  --totp-code CODE 6-digit code from your authenticator app\n"
                 "  --no-save        Don't save token to config (non-interactive only)\n"
                 "  -h, --help       Show this help message\n\n"
                 "[bold cyan]Token Storage:[/bold cyan]\n"
@@ -364,13 +346,18 @@ def main() -> NoReturn:
             code_idx = args.index("--code")
             code = args[code_idx + 1] if code_idx + 1 < len(args) else None
 
+        totp_code = None
+        if "--totp-code" in args:
+            totp_idx = args.index("--totp-code")
+            totp_code = args[totp_idx + 1] if totp_idx + 1 < len(args) else None
+
         no_save = "--no-save" in args
 
         if not email:
             print("Error: --email requires an email address")
             exit(1)
 
-        result = auth_non_interactive(email, code, auto_save=not no_save)
+        result = auth_non_interactive(email, code, auto_save=not no_save, totp_code=totp_code)
         exit(0 if result or code is None else 1)
 
     # Interactive mode (original behavior)
@@ -387,8 +374,10 @@ def main() -> NoReturn:
         console.print("  Check your email for a [bold]6-digit code[/bold] or [bold]magic link[/bold].")
         user_input = Prompt.ask("  Enter code or paste link", console=console).strip()
         redirect_url = _validate_and_get_redirect_url(session, email, user_input)
-
-        token = _extract_session_token(session, redirect_url)
+        challenge_token = follow_auth_callback(session, redirect_url)
+        if challenge_token:
+            _prompt_and_verify_totp(session, challenge_token)
+        token = extract_session_token(session)
 
         _display_and_save_token(token)
 

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/cli/setup.py

@@ -22,7 +22,12 @@ from rich.prompt import Confirm, Prompt
 from rich.syntax import Syntax
 from rich.table import Table
 import rich_click as click
-import tomllib
+
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # Python 3.10
+    import tomli as tomllib
 
 
 console = Console()

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/constants.py

@@ -9,6 +9,12 @@ from typing import Final
 API_VERSION: Final[str] = "2.18"
 """Current API version used by Perplexity WebUI."""
 
+APP_HEADERS: Final[dict[str, str]] = {
+    "x-app-apiclient": "default",
+    "x-app-apiversion": API_VERSION,
+}
+"""Headers used by the Perplexity web application for internal API requests."""
+
 API_BASE_URL: Final[str] = "https://www.perplexity.ai"
 """Base URL for all API requests."""
 
@@ -52,6 +58,7 @@ JSON_OBJECT_PATTERN: Final[Pattern[str]] = compile(r"^\{.*\}$")
 """Pattern to detect JSON object strings."""
 
 DEFAULT_HEADERS: Final[dict[str, str]] = {
+    **APP_HEADERS,
     "Accept": "text/event-stream, application/json",
     "Content-Type": "application/json",
 }

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/core.py

@@ -590,10 +590,12 @@ class Conversation:
         except KeyError as error:
             raise ResponseParsingError("Missing 'text' field in data", raw_data=str(data)) from error
         except JSONDecodeError as error:
-            print("ERROR DATA:", data.get("text"))
-            raise ResponseParsingError(
-                "Invalid JSON in 'text' field", raw_data=str(data.get("text", ""))[:500]
-            ) from error
+            raw_text = data.get("text", "")
+            logger.warning(f"Non-JSON text in SSE data: {raw_text[:200]}")
+            stripped = raw_text.lstrip()
+            if stripped and not stripped.startswith(("{", "[")):
+                raise ResponseParsingError(raw_text) from error
+            raise ResponseParsingError("Invalid JSON in 'text' field", raw_data=str(raw_text)[:500]) from error
 
         answer_data: dict[str, Any] = {}
 

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/data/SKILL.md

@@ -2,7 +2,7 @@
 name: perplexity-web-mcp
 description: 'Search the web and query AI models via Perplexity AI using perplexity-web-mcp-cli. Supports CLI commands (pwm ask, pwm research), MCP tools (pplx_*), and Anthropic/OpenAI-compatible API server. Use when the user mentions "perplexity", "pplx", "pwm", "web search with AI", "deep research", "search the internet", or wants to query premium models like GPT-5.6 Terra, GPT-5.6 Sol, Grok, Claude, Gemini, GLM, or Nemotron through Perplexity''s web interface.'
 metadata:
-  version: "0.14.2"
+  version: "0.14.4"
   author: "Jacob BD"
 ---
 
@@ -209,8 +209,8 @@ User wants to...
 |
 +-- Authenticate / re-authenticate
 |   +-- Interactive:      pwm login
-|   +-- Non-interactive:  pwm login --email EMAIL  then  pwm login --email EMAIL --code CODE
-|   +-- MCP (no shell):   pplx_auth_request_code(email)  then  pplx_auth_complete(email, code)
+|   +-- Non-interactive:  pwm login --email EMAIL, then pwm login --email EMAIL --code CODE [--totp-code CODE]
+|   +-- MCP (no shell):   pplx_auth_request_code(email), then pplx_auth_complete(email, code[, totp_code])
 |
 +-- Start MCP server
 |   +-- pwm-mcp
@@ -326,8 +326,11 @@ pwm login                                                # Interactive
 pwm login --check                                        # Check status
 pwm login --email user@example.com                       # Send code
 pwm login --email user@example.com --code 123456         # Complete
+pwm login --email user@example.com --code 123456 --totp-code 654321  # Complete with TOTP
 ```
 
+Set `PWM_SAVE_TO_LIBRARY=1` to save shared CLI and MCP queries to the Perplexity thread library. Queries are incognito by default.
+
 ### Usage
 
 ```bash
@@ -360,7 +363,7 @@ pwm usage --refresh         # Force-refresh from server
 | `pplx_connectors`               | FREE                                    | List account connector source IDs for `source_focus`                                                                                                                                   |
 | `pplx_auth_status`              | FREE                                    | Check auth status                                                                                                                                                                      |
 | `pplx_auth_request_code`        | FREE                                    | Send verification code                                                                                                                                                                 |
-| `pplx_auth_complete`            | FREE                                    | Complete auth with code                                                                                                                                                                |
+| `pplx_auth_complete`            | FREE                                    | Complete email and optional TOTP authentication                                                                                                                                         |
 
 All query tools accept `source_focus`: `"none"`, `"web"`, `"academic"`, `"social"`, `"finance"`, `"all"`, or a connector source ID from `pplx_connectors()`.
 Use `source_focus="none"` for model-only queries without web search.
@@ -513,6 +516,7 @@ pwm login --check && pwm usage
 pwm login --email user@example.com
 # wait for email, then:
 pwm login --email user@example.com --code 123456
+# For a TOTP-enabled account, include: --totp-code 654321
 ```
 
 ## API Server

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/data/references/mcp-tools.md

@@ -255,10 +255,13 @@ Complete authentication with the verification code. Second step of re-authentica
 ```
 pplx_auth_complete(
     email: str,                    # Required. Same email used in pplx_auth_request_code.
-    code: str,                     # Required. 6-digit code from email.
+    code: str = "",                # 6-digit code from email.
+    totp_code: str | None = None,  # Authenticator code when TOTP is enabled.
 ) -> str
 ```
 
+If the first completion call returns `TOTP_REQUIRED`, call the tool again with `email` and `totp_code`.
+
 ## Response Format
 
 All query tools return a string containing:

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/mcp/server.py

@@ -13,6 +13,14 @@ import uuid
 
 from fastmcp import FastMCP
 
+from perplexity_web_mcp.auth import (
+    create_auth_session,
+    extract_session_token,
+    follow_auth_callback,
+    request_verification_code,
+    resolve_redirect_url,
+    verify_totp,
+)
 from perplexity_web_mcp.models import Models
 from perplexity_web_mcp.shared import (
     COUNCIL_DEFAULT_MODELS_STR,
@@ -74,7 +82,7 @@ mcp = FastMCP(
         "AUTHENTICATION: If you get a 403 error or 'token expired' message:\n"
         "1. pplx_auth_status — check current authentication status\n"
         "2. pplx_auth_request_code — send verification code to email\n"
-        "3. pplx_auth_complete — complete auth with the 6-digit code"
+        "3. pplx_auth_complete — complete email OTP and any requested TOTP challenge"
     ),
 )
 
@@ -683,33 +691,9 @@ def pplx_auth_request_code(email: str) -> str:
     Returns:
         Status message indicating if the code was sent successfully
     """
-    from curl_cffi.requests import Session
-    from orjson import loads
-
-    BASE_URL = "https://www.perplexity.ai"
-
     try:
-        session = Session(impersonate="chrome", headers={"Referer": BASE_URL, "Origin": BASE_URL})
-        session.get(BASE_URL)
-        csrf_data = loads(session.get(f"{BASE_URL}/api/auth/csrf").content)
-        csrf = csrf_data.get("csrfToken")
-
-        if not csrf:
-            return "ERROR: Failed to obtain CSRF token. Please try again."
-
-        response = session.post(
-            f"{BASE_URL}/api/auth/signin/email?version=2.18&source=default",
-            json={
-                "email": email,
-                "csrfToken": csrf,
-                "useNumericOtp": "true",
-                "json": "true",
-                "callbackUrl": f"{BASE_URL}/?login-source=floatingSignup",
-            },
-        )
-
-        if response.status_code != 200:
-            return f"ERROR: Failed to send verification code. Status: {response.status_code}"
+        session, csrf = create_auth_session()
+        request_verification_code(session, csrf, email)
 
         _set_auth_session({"session": session, "email": email})
 
@@ -725,7 +709,7 @@ def pplx_auth_request_code(email: str) -> str:
 
 
 @mcp.tool
-def pplx_auth_complete(email: str, code: str) -> str:
+def pplx_auth_complete(email: str, code: str = "", totp_code: str | None = None) -> str:
     """Complete Perplexity authentication with the verification code.
 
     Use the 6-digit code received via email after calling pplx_auth_request_code.
@@ -734,50 +718,37 @@ def pplx_auth_complete(email: str, code: str) -> str:
     Args:
         email: Your Perplexity account email (same as used in pplx_auth_request_code)
         code: The 6-digit verification code from your email
+        totp_code: The 6-digit authenticator code when TOTP is enabled
 
     Returns:
         Status message with authentication result and subscription tier
     """
-    from curl_cffi.requests import Session
-    from orjson import loads
-
     from perplexity_web_mcp.cli.auth import get_user_info
 
-    BASE_URL = "https://www.perplexity.ai"
-    SESSION_COOKIE_NAME = "__Secure-next-auth.session-token"
-
     try:
         stored = _get_auth_session(email)
         if stored:
             session = stored["session"]
         else:
-            session = Session(impersonate="chrome", headers={"Referer": BASE_URL, "Origin": BASE_URL})
-            session.get(BASE_URL)
-
-        response = session.post(
-            f"{BASE_URL}/api/auth/otp-redirect-link",
-            json={
-                "email": email,
-                "otp": code,
-                "redirectUrl": f"{BASE_URL}/?login-source=floatingSignup",
-                "emailLoginMethod": "web-otp",
-            },
-        )
-
-        if response.status_code != 200:
-            return "ERROR: Invalid verification code. Please check and try again."
-
-        redirect_path = loads(response.content).get("redirect")
-        if not redirect_path:
-            return "ERROR: No redirect URL received. Please try again."
+            session, _ = create_auth_session()
 
-        redirect_url = f"{BASE_URL}{redirect_path}" if redirect_path.startswith("/") else redirect_path
-
-        session.get(redirect_url)
-        token = session.cookies.get(SESSION_COOKIE_NAME)
-
-        if not token:
-            return "ERROR: Authentication succeeded but token not found."
+        challenge_token = stored.get("challenge_token") if stored else None
+        if challenge_token:
+            if not totp_code:
+                return "TOTP_REQUIRED: Call pplx_auth_complete again with email and totp_code."
+            verify_totp(session, challenge_token, totp_code)
+        else:
+            if not code:
+                return "ERROR: The 6-digit email verification code is required."
+            redirect_url = resolve_redirect_url(session, email, code)
+            challenge_token = follow_auth_callback(session, redirect_url)
+            if challenge_token:
+                _set_auth_session({"session": session, "email": email, "challenge_token": challenge_token})
+                if not totp_code:
+                    return "TOTP_REQUIRED: Call pplx_auth_complete again with email and totp_code."
+                verify_totp(session, challenge_token, totp_code)
+
+        token = extract_session_token(session)
 
         if save_token(token):
             _clear_auth_session()

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/rate_limits.py

@@ -17,7 +17,14 @@ from typing import Any
 
 from curl_cffi.requests import Session
 
-from .constants import API_BASE_URL, ENDPOINT_CREDITS, ENDPOINT_RATE_LIMITS, ENDPOINT_USER_SETTINGS, SESSION_COOKIE_NAME
+from .constants import (
+    API_BASE_URL,
+    APP_HEADERS,
+    ENDPOINT_CREDITS,
+    ENDPOINT_RATE_LIMITS,
+    ENDPOINT_USER_SETTINGS,
+    SESSION_COOKIE_NAME,
+)
 from .logging import get_logger
 
 
@@ -304,7 +311,12 @@ def _create_session(token: str) -> Session:
     """Create a minimal session for REST API calls."""
     return Session(
         impersonate="chrome",
-        headers={"Referer": API_BASE_URL, "Origin": API_BASE_URL},
+        headers={
+            **APP_HEADERS,
+            "Referer": API_BASE_URL,
+            "Origin": API_BASE_URL,
+            "Accept": "application/json",
+        },
         cookies={SESSION_COOKIE_NAME: token},
     )
 

{perplexity_web_mcp_cli-0.14.2 → perplexity_web_mcp_cli-0.14.4}/src/perplexity_web_mcp/shared.py

@@ -278,6 +278,11 @@ def _shared_client_config_from_env() -> ClientConfig:
     )
 
 
+def _save_to_library_from_env() -> bool:
+    """Return whether shared CLI/MCP queries should be saved to the library."""
+    return environ.get("PWM_SAVE_TO_LIBRARY", "").strip().lower() in {"1", "true", "yes", "on"}
+
+
 def get_client() -> Perplexity:
     """Get or create a cached Perplexity client.
 
@@ -390,6 +395,7 @@ def _execute_query(
             citation_mode=CitationMode.DEFAULT,
             search_focus=search_focus,
             source_focus=sources,
+            save_to_library=_save_to_library_from_env(),
         )
     )