deepwrap 0.1.0__py3-none-any.whl

deepwrap/modules/__init__.py

@@ -0,0 +1,3 @@
+from .pow_asm import ProofOfWorkSolver, PowChallenge
+
+__all__ = ["ProofOfWorkSolver", "PowChallenge"]

deepwrap/modules/pow_asm.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import os
+import struct
+import urllib.request
+
+from dataclasses import dataclass
+from typing import Optional
+
+from wasmtime import Instance, Store
+from deepwrap.config import Config
+
+@dataclass(frozen=True)
+class PowChallenge:
+    """
+    Represents a DeepSeek proof-of-work challenge.
+
+    This object contains all server-provided fields required to solve the
+    challenge and build the `x-ds-pow-response` header.
+
+    Attributes:
+        algorithm:
+            The PoW algorithm identifier returned by the API, such as
+            "DeepSeekHashV1".
+
+        challenge:
+            The hex-encoded challenge string passed to the WASM solver.
+
+        salt:
+            The server-provided salt used to build the solver prefix.
+
+        signature:
+            The server-provided signature that must be echoed back unchanged
+            in the PoW response payload.
+
+        difficulty:
+            The difficulty value passed to the WASM solver.
+
+        expire_at:
+            Challenge expiration timestamp in Unix milliseconds.
+
+        expire_after:
+            Challenge lifetime in milliseconds.
+
+        target_path:
+            The API path this challenge was issued for, such as
+            "/api/v0/chat/completion".
+    """
+
+    algorithm: str
+    challenge: str
+    salt: str
+    signature: str
+    difficulty: int
+    expire_at: int
+    expire_after: int
+    target_path: str
+
+
+class ProofOfWorkSolver:
+    """
+    Solves DeepSeek proof-of-work challenges using the browser-compatible WASM module.
+
+    Browser worker behavior:
+        prefix = f"{salt}_{expireAt}_"
+        wasm_solve(ret_ptr, challenge_ptr, challenge_len, prefix_ptr, prefix_len, difficulty)
+        ok     = getInt32(ret_ptr + 0, little_endian=True)
+        answer = getFloat64(ret_ptr + 8, little_endian=True)
+
+    Notes:
+        - The second string passed into the solver is the prefix, not the raw salt.
+        - The final numeric argument is `difficulty` as float64.
+        - `expire_at` is used only when building the prefix string.
+    """
+
+    def __init__(self, wasm_path: Optional[str] = None) -> None:
+        """
+        Initialize the solver.
+
+        Args:
+            wasm_path:
+                Optional local path to the PoW WASM binary. If omitted, the WASM
+                module is downloaded from the configured URL.
+        """
+
+        self._wasm_path = wasm_path
+        self._wasm_bytes: Optional[bytes] = None
+        self._engine = None
+        self._module = None
+
+    def _load_bytes(self) -> bytes:
+        """
+        Load the WASM module bytes.
+
+        The bytes are loaded once and cached in memory. If `wasm_path` points
+        to an existing file, that file is used. Otherwise, the module is
+        downloaded from `Config.wasm_url`.
+
+        Returns:
+            The raw WASM bytes.
+        """
+
+        if self._wasm_bytes is not None:
+            return self._wasm_bytes
+
+        if self._wasm_path and os.path.isfile(self._wasm_path):
+            with open(self._wasm_path, "rb") as fh:
+                self._wasm_bytes = fh.read()
+            return self._wasm_bytes
+
+        with urllib.request.urlopen(Config.wasm_url, timeout=20) as resp:
+            self._wasm_bytes = resp.read()
+
+        return self._wasm_bytes
+
+    def _write(self, ptr: int, data: bytes, memory, store) -> None:
+        """
+        Write bytes into WASM linear memory.
+
+        Args:
+            ptr:
+                Destination pointer inside WASM memory.
+            data:
+                Bytes to write.
+            memory:
+                Exported WASM memory object.
+            store:
+                The active WASM store.
+        """
+        
+        raw = memory.data_ptr(store)
+
+        for i, b in enumerate(data):
+            raw[ptr + i] = b
+
+    def _read(self, ptr: int, size: int, memory, store) -> bytes:
+        """
+        Read bytes from WASM linear memory.
+
+        Args:
+            ptr:
+                Source pointer inside WASM memory.
+            size:
+                Number of bytes to read.
+            memory:
+                Exported WASM memory object.
+            store:
+                The active WASM store.
+
+        Returns:
+            The bytes read from WASM memory.
+        """
+
+        return bytes(memory.data_ptr(store)[ptr + i] for i in range(size))
+
+    def _pass_string(self, value: str, malloc, realloc, memory, store) -> tuple[int, int]:
+        """
+        Copy a Python string into WASM memory.
+
+        This mirrors the wasm-bindgen string-passing behavior used by the
+        browser worker. ASCII-only strings use a fast path; non-ASCII strings
+        fall back to reallocation-based UTF-8 encoding.
+
+        Args:
+            value:
+                The Python string to copy.
+            malloc:
+                WASM malloc export.
+            realloc:
+                WASM realloc export.
+            memory:
+                Exported WASM memory object.
+            store:
+                The active WASM store.
+
+        Returns:
+            A tuple of `(ptr, length)` describing the copied UTF-8 string in
+            WASM memory.
+        """
+
+        encoded = value.encode("utf-8")
+
+        if all(b < 128 for b in encoded):
+            ptr = malloc(store, len(encoded), 1)
+            self._write(ptr, encoded, memory, store)
+
+            return ptr, len(encoded)
+
+        ptr = malloc(store, len(value), 1)
+        raw = memory.data_ptr(store)
+        offset = 0
+
+        while offset < len(value):
+            ch = ord(value[offset])
+
+            if ch > 127:
+                break
+
+            raw[ptr + offset] = ch
+            offset += 1
+
+        if offset != len(value):
+            remainder = value[offset:].encode("utf-8")
+            ptr = realloc(store, ptr, len(value), offset + len(remainder), 1)
+            self._write(ptr + offset, remainder, memory, store)
+
+            return ptr, offset + len(remainder)
+
+        return ptr, offset
+
+    def warmup(self) -> None:
+        """
+        Preload and compile the WASM module.
+
+        This reduces latency for the first challenge solve by downloading and
+        compiling the module ahead of time. Repeated calls are no-ops.
+
+        Raises:
+            RuntimeError:
+                If the `wasmtime` dependency is missing.
+        """
+
+        if self._module is not None:
+            return
+
+        try:
+            from wasmtime import Engine, Module
+
+        except ImportError as exc:
+            raise RuntimeError(
+                "Missing dependency: wasmtime. Install it with: pip install wasmtime"
+            ) from exc
+
+        self._engine = Engine()
+        self._module = Module(self._engine, self._load_bytes())
+
+    def solve(self, challenge: PowChallenge) -> int:
+        """
+        Solve a DeepSeek proof-of-work challenge.
+
+        Args:
+            challenge:
+                The server-issued proof-of-work challenge.
+
+        Returns:
+            The integer nonce that satisfies the challenge.
+
+        Raises:
+            RuntimeError:
+                If the WASM solver reports that no valid solution was found.
+        """
+
+        if self._module is None:
+            self.warmup()
+
+        store = Store(self._engine)
+        instance = Instance(store, self._module, [])
+        exports = instance.exports(store)
+
+        memory = exports["memory"]
+        malloc = exports["__wbindgen_export_0"]
+        realloc = exports["__wbindgen_export_1"]
+        stack_ptr_fn = exports["__wbindgen_add_to_stack_pointer"]
+        wasm_solve = exports["wasm_solve"]
+
+        challenge_ptr, challenge_len = self._pass_string(
+            challenge.challenge, malloc, realloc, memory, store
+        )
+        
+        prefix_ptr, prefix_len = self._pass_string(
+            f"{challenge.salt}_{challenge.expire_at}_", 
+            malloc, 
+            realloc, 
+            memory, 
+            store
+        )
+
+        ret_ptr = stack_ptr_fn(store, -16)
+        try:
+            wasm_solve(
+                store,
+                ret_ptr,
+                challenge_ptr,
+                challenge_len,
+                prefix_ptr,
+                prefix_len,
+                float(challenge.difficulty),
+            )
+
+            raw = self._read(ret_ptr, 16, memory, store)
+            ok = struct.unpack_from("<i", raw, 0)[0]
+            answer = struct.unpack_from("<d", raw, 8)[0]
+
+        finally:
+            stack_ptr_fn(store, 16)
+
+        if ok == 0:
+            raise RuntimeError(
+                "No solution found: "
+                f"algorithm={challenge.algorithm}, "
+                f"challenge={challenge.challenge}, "
+                f"difficulty={challenge.difficulty}, "
+            )
+
+        return int(answer)

deepwrap/utils/bearer_token_extractor.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict, Optional
+
+class BearerTokenExtractor:
+    """
+    Utility class to extract bearer tokens from CDP messages.
+    """
+    
+    @staticmethod
+    def from_headers(headers: Optional[Dict[str, Any]]) -> Optional[str]:
+        """
+        Extract a bearer token from the given headers dictionary.
+        
+        Args:
+            headers (Optional[Dict[str, Any]]): A dictionary of HTTP headers.
+
+        Returns:
+            Optional[str]: The extracted bearer token if found, otherwise None.
+        """
+
+        if not headers:
+            return None
+
+        for key, value in headers.items():
+            if key.lower() != "authorization":
+                continue
+
+            value = str(value)
+
+            if value.lower().startswith("bearer "):
+                return value.split(" ", 1)[1]
+
+        return None
+
+    @classmethod
+    def from_cdp_message(cls, message: Dict[str, Any]) -> Optional[str]:
+        """
+        Extract a bearer token from a CDP message if it contains relevant network request information.
+        
+        Args:
+            message (Dict[str, Any]): A CDP message represented as a dictionary.
+        
+        Returns:
+            Optional[str]: The extracted bearer token if found, otherwise None.
+        """
+        
+        method = message.get("method")
+        params = message.get("params", {})
+
+        if method == "Network.requestWillBeSent":
+            request = params.get("request", {})
+            return cls.from_headers(request.get("headers", {}))
+
+        if method == "Network.requestWillBeSentExtraInfo":
+            return cls.from_headers(params.get("headers", {}))
+
+        return None

deepwrap/utils/browser_finder.py

@@ -0,0 +1,172 @@
+import os
+import sys
+
+from pathlib import Path
+from shutil import which
+from typing import Any, List
+
+class BrowserFinder:
+    """
+    Utility class to find installed Chromium-based browsers on the system.
+    This is used by the authentication module to launch a browser instance for user login when no active session is found.
+    The finder checks common installation paths for major browsers across Windows, macOS, and Linux, as well as the system PATH.
+    """
+    
+    CHROMIUM_EXECUTABLE_NAMES = [
+        "chrome",
+        "chrome.exe",
+        "msedge",
+        "msedge.exe",
+        "brave",
+        "brave.exe",
+        "brave-browser",
+        "chromium",
+        "chromium-browser",
+        "opera",
+        "opera.exe",
+        "vivaldi",
+        "vivaldi.exe",
+    ]
+
+    @classmethod
+    def find(cls) -> List[str]:
+        """
+        Find installed Chromium-based browsers.
+        
+        Returns:
+            A list of file paths to detected browser executables. The list may be empty if no browsers are found.
+        """
+        
+        paths = []
+        paths.extend(cls._from_path())
+
+        if sys.platform.startswith("win"):
+            paths.extend(cls._windows_paths())
+
+        elif sys.platform == "darwin":
+            paths.extend(cls._macos_paths())
+
+        else:
+            paths.extend(cls._linux_paths())
+
+        return cls._unique_existing(paths)
+
+    @classmethod
+    def _from_path(cls) -> List[str]:
+        """
+        Find browser executables in the system PATH.
+        
+        Returns:
+            A list of file paths to browser executables found in the PATH.
+        """
+
+        paths = []
+
+        for name in cls.CHROMIUM_EXECUTABLE_NAMES:
+            found = which(name)
+
+            if found:
+                paths.append(found)
+
+        return paths
+
+    @staticmethod
+    def _windows_paths() -> List[Path]:
+        """
+        Common installation paths for Chromium-based browsers on Windows.
+        
+        Returns:
+            A list of file paths to browser executables based on common Windows installation directories.
+        """
+        
+        local = os.environ.get("LOCALAPPDATA", "")
+        pf = os.environ.get("PROGRAMFILES", "")
+        pf86 = os.environ.get("PROGRAMFILES(X86)", "")
+
+        return [
+            Path(local) / "Google" / "Chrome" / "Application" / "chrome.exe",
+            Path(pf) / "Google" / "Chrome" / "Application" / "chrome.exe",
+            Path(pf86) / "Google" / "Chrome" / "Application" / "chrome.exe",
+
+            Path(local) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
+            Path(pf) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
+            Path(pf86) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
+
+            Path(local) / "BraveSoftware" / "Brave-Browser" / "Application" / "brave.exe",
+            Path(pf) / "BraveSoftware" / "Brave-Browser" / "Application" / "brave.exe",
+            Path(pf86) / "BraveSoftware" / "Brave-Browser" / "Application" / "brave.exe",
+
+            Path(local) / "Programs" / "Opera" / "opera.exe",
+            Path(pf) / "Opera" / "opera.exe",
+
+            Path(local) / "Vivaldi" / "Application" / "vivaldi.exe",
+            Path(pf) / "Vivaldi" / "Application" / "vivaldi.exe",
+        ]
+
+    @staticmethod
+    def _macos_paths() -> List[str]:
+        """
+        Common installation paths for Chromium-based browsers on macOS.
+        
+        Returns:
+            A list of file paths to browser executables based on common macOS installation directories.
+        """
+
+        return [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            "/Applications/Opera.app/Contents/MacOS/Opera",
+            "/Applications/Vivaldi.app/Contents/MacOS/Vivaldi",
+        ]
+
+    @staticmethod
+    def _linux_paths() -> List[str]:
+        """
+        Common installation paths for Chromium-based browsers on Linux.
+        
+        Returns:
+            A list of file paths to browser executables based on common Linux installation directories.
+        """
+
+        return [
+            "/usr/bin/google-chrome",
+            "/usr/bin/google-chrome-stable",
+            "/usr/bin/chromium",
+            "/usr/bin/chromium-browser",
+            "/usr/bin/microsoft-edge",
+            "/usr/bin/brave-browser",
+            "/usr/bin/opera",
+            "/usr/bin/vivaldi",
+            "/snap/bin/chromium",
+            "/snap/bin/brave",
+        ]
+
+    @staticmethod
+    def _unique_existing(paths: List[Any]) -> List[str]:
+        """
+        Filter the given list of paths to include only unique entries that exist on the filesystem.
+        
+        Returns:
+            A list of unique file paths that exist on the filesystem.
+        """
+        
+        seen = set()
+        result = []
+
+        for path in paths:
+            if not path:
+                continue
+
+            path = str(Path(path))
+            normalized = path.lower()
+
+            if normalized in seen:
+                continue
+
+            if Path(path).exists():
+                seen.add(normalized)
+                result.append(path)
+
+        return result

deepwrap/utils/browser_process.py

@@ -0,0 +1,72 @@
+
+import subprocess
+import tempfile
+import shutil
+
+from typing import Optional
+from .browser_finder import BrowserFinder
+
+class BrowserProcess:
+    """
+    Manages the lifecycle of a browser process launched for authentication.
+    """
+    
+    def __init__(self, url: str, port: int) -> None:
+        self.url = url
+        self.port = port
+        self.process: Optional[subprocess.Popen] = None
+        self.browser_path: Optional[str] = None
+        self.user_data_dir: Optional[str] = None
+
+    def start(self) -> "BrowserProcess":
+        """
+        Start the browser process with the appropriate flags for remote debugging.
+        """
+        
+        browsers = BrowserFinder.find()
+
+        if not browsers:
+            raise Exception(
+                "No Chromium-based browser was found. Please install Chrome, Edge, Brave, Chromium, Opera, or Vivaldi."
+            )
+
+        self.browser_path = browsers[0]
+        self.user_data_dir = tempfile.mkdtemp(prefix="deepwrap-auth-profile-")
+
+        args = [
+            self.browser_path,
+            f"--remote-debugging-port={self.port}",
+            "--remote-debugging-address=127.0.0.1",
+            "--remote-allow-origins=*",
+            f"--user-data-dir={self.user_data_dir}",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-popup-blocking",
+            self.url,
+        ]
+
+        self.process = subprocess.Popen(
+            args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        return self
+
+    def terminate(self) -> None:
+        """
+        Terminate the browser process and clean up the user data directory.
+        """
+        
+        if self.process:
+            try:
+                self.process.terminate()
+
+            except Exception:
+                pass
+
+        if self.user_data_dir:
+            try:
+                shutil.rmtree(self.user_data_dir, ignore_errors=True)
+            except Exception:
+                pass

deepwrap/utils/cdp_client.py

@@ -0,0 +1,82 @@
+import json
+import websocket
+
+from typing import Dict, Any, Optional
+
+class CDPClient:
+    """
+    Simple wrapper around a DevTools Protocol WebSocket connection.
+     - Provides methods to send commands and receive responses from the DevTools interface.
+     - Manages message IDs and connection lifecycle.
+     - Includes convenience methods to enable the Network and Page domains and to close the browser.
+    """
+    
+    def __init__(self, websocket_url: str, timeout: int = 1) -> None:
+        self.websocket_url = websocket_url
+        self.timeout = timeout
+        self.message_id = 0
+        self.ws = websocket.create_connection(
+            websocket_url,
+            timeout=timeout,
+            suppress_origin=True,
+        )
+
+    def send(self, method: str, params: Optional[Dict[str, Any]] = None) -> int:
+        """
+        Send a command to the DevTools interface.
+        
+        Args:
+            method (str): The DevTools method to invoke (e.g., "Network.enable").
+            params (Optional[Dict[str, Any]]): An optional dictionary of parameters to include with the command.
+        
+        Returns:
+                int: The message ID assigned to this command, which can be used to correlate responses.
+        """
+
+        self.message_id += 1
+
+        payload = {
+            "id": self.message_id,
+            "method": method,
+        }
+
+        if params is not None:
+            payload["params"] = params
+
+        self.ws.send(json.dumps(payload))
+        return self.message_id
+
+    def recv(self) -> Dict[str, Any]:
+        """
+        Receive a message from the DevTools interface and parse it as JSON.
+        """
+        
+        return json.loads(self.ws.recv())
+
+    def enable_network(self) -> None:
+        """
+        Convenience method to enable the Network domain.
+        """
+        
+        self.send("Network.enable")
+        self.send("Page.enable")
+
+    def close_browser(self) -> None:
+        """
+        Send the command to close the browser window.
+        """
+        
+        try:
+            self.send("Browser.close")
+        except Exception:
+            pass
+
+    def close(self) -> None:
+        """
+        Close the WebSocket connection.
+        """
+        
+        try:
+            self.ws.close()
+        except Exception:
+            pass