recurl-cli 0.1.2__py3-none-any.whl

recurl/__init__.py

@@ -0,0 +1,60 @@
+"""
+recurl - Drop-in curl replacement with automatic anti-bot bypass
+
+This is a thin Python wrapper that delegates to the platform-specific
+binary downloaded at install time.
+"""
+
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _find_binary(name: str) -> str:
+    """Locate the downloaded recurl binary."""
+    # 1. Check alongside this package
+    package_dir = Path(__file__).parent
+    bin_path = package_dir / "bin" / name
+    if bin_path.exists():
+        return str(bin_path)
+
+    # 2. Check in PATH
+    found = shutil.which(name)
+    if found:
+        return found
+
+    raise FileNotFoundError(
+        f"Could not find {name} binary. "
+        "Try reinstalling: pip install --force-reinstall recurl-cli"
+    )
+
+
+def run(args: list[str] = None) -> int:
+    """
+    Run recurl with the given CLI arguments.
+
+    Args:
+        args: List of arguments (e.g., ["-s", "https://example.com"]).
+              If None, uses sys.argv[1:].
+
+    Returns:
+        Exit code from the recurl process.
+    """
+    import shutil
+
+    binary = _find_binary("recurl")
+    cmd = [binary] + (args if args is not None else sys.argv[1:])
+    result = subprocess.run(cmd)
+    return result.returncode
+
+
+def run_daemon(args: list[str] = None) -> int:
+    """Run recurld with the given CLI arguments."""
+    import shutil
+
+    binary = _find_binary("recurld")
+    cmd = [binary] + (args if args is not None else sys.argv[1:])
+    result = subprocess.run(cmd)
+    return result.returncode

recurl/bin/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neul Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

recurl/bin/README.md

@@ -0,0 +1,225 @@
+# recurl
+
+[![Crates.io](https://img.shields.io/crates/v/recurl.svg)](https://crates.io/crates/recurl)
+[![Documentation](https://img.shields.io/badge/docs-docs.neullabs.com-blue)](https://docs.neullabs.com/recurl)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/neul-labs/recurl/ci.yml?branch=main)](https://github.com/neul-labs/recurl/actions)
+
+**curl that just works.** Drop-in replacement with automatic anti-bot bypass.
+
+---
+
+## Why recurl?
+
+You're scraping a website. It works in your browser but `curl` gets blocked. You try different headers, user agents, maybe even `curl-impersonate`. Still blocked. Now you're writing Puppeteer scripts...
+
+**recurl fixes this.** It runs real curl, detects when you're blocked, and automatically escalates through impersonation and headless browser rendering. Same curl syntax you know. No code changes.
+
+```bash
+# This just works, even on Cloudflare-protected sites
+recurl https://protected-site.com/api/data
+```
+
+## Installation
+
+```bash
+# npm / npx
+npm install -g recurl-cli
+
+# PyPI
+pip install recurl-cli
+
+# Homebrew (macOS / Linux)
+brew tap neul-labs/tap
+brew install recurl
+
+# Cargo (Rust)
+cargo install recurl
+
+# From source
+git clone https://github.com/neul-labs/recurl
+cd recurl && cargo build --release
+```
+
+## Quick Start
+
+```bash
+# Use it exactly like curl
+recurl https://example.com
+
+# Or alias it as curl for seamless usage
+alias curl=recurl
+curl https://api.example.com/data
+
+# Force JS rendering for heavy protection
+recurl --recurl-js https://heavily-protected-site.com
+
+# Debug mode to see what's happening
+recurl --recurl-debug https://example.com
+```
+
+## How It Works
+
+```
+curl (alias) --> recurl (shim)
+                    |
+                    +--> curl_engine --> success? done
+                    |
+                    +--> blocked? (403, 429, captcha, etc.)
+                           |
+                           +--> retry with impersonation (TLS fingerprint spoofing)
+                           |
+                           +--> retry with JS preflight (headless Chromium)
+```
+
+1. **First try**: Runs real curl (fast, low overhead)
+2. **If blocked**: Retries with TLS fingerprint impersonation
+3. **Still blocked**: Renders page in headless Chromium, captures cookies/tokens, replays request
+
+Chromium auto-downloads on first use. A background daemon (`recurld`) keeps it warm for fast subsequent requests.
+
+## Bypass Coverage
+
+recurl automatically handles:
+
+| Provider | Detection Method |
+|----------|------------------|
+| Cloudflare | Bot Management, Turnstile, JS Challenge |
+| Akamai | Bot Manager |
+| PerimeterX | HUMAN Security |
+| DataDome | Bot Protection |
+| Imperva | Incapsula |
+| Kasada | Bot Mitigation |
+| AWS WAF | Bot Control |
+| Shape/F5 | Bot Defense |
+| Arkose Labs | FunCaptcha |
+| hCaptcha | Challenge |
+| reCAPTCHA | Challenge |
+
+## CLI Reference
+
+### recurl-specific flags
+
+| Flag | Description |
+|------|-------------|
+| `--recurl-strict` | Disable fallback, pure curl passthrough |
+| `--recurl-impersonate <profile>` | Force specific TLS fingerprint profile |
+| `--recurl-js` | Force JS preflight (skip to Chromium) |
+| `--recurl-js-rendered` | Return rendered DOM instead of raw response |
+| `--recurl-js-wait <selector>` | Wait for CSS selector before capturing |
+| `--recurl-js-timeout <ms>` | JS preflight timeout (default: 30000) |
+| `--recurl-daemon on\|off` | Control background daemon usage |
+| `--recurl-debug` | Show diagnostic output |
+
+All standard curl flags work as expected.
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `RECURL_STRICT=1` | Same as `--recurl-strict` |
+| `RECURL_DAEMON_IDLE_MS` | Daemon idle timeout (default: 60000) |
+
+## Platform Support
+
+| Platform | Arch | Impersonation | JS Preflight | Chromium Auto-Download |
+|----------|------|:-------------:|:------------:|:----------------------:|
+| Linux | x86_64 | Yes | Yes | Yes |
+| Linux | aarch64 | Yes | Yes | Manual |
+| macOS | Apple Silicon | Yes | Yes | Yes |
+| macOS | Intel | Yes | Yes | Yes |
+| Windows | x86_64 | No | Yes | Yes |
+
+*Impersonation requires curl-impersonate (Linux/macOS only). Windows skips directly to JS preflight.*
+
+## For Developers
+
+### Building from Source
+
+```bash
+# Debug build
+cargo build
+
+# Release build (optimized)
+cargo build --release
+
+# Build with daemon support
+cargo build --release --features daemon
+```
+
+### Architecture
+
+```
+src/
+  main.rs                    # CLI entry point, argument parsing
+  engine.rs                  # curl_engine execution layer
+  detection/                 # Anti-bot pattern detection
+    mod.rs
+    patterns.rs
+    status.rs
+  impersonation/             # TLS fingerprint impersonation
+    mod.rs
+  js_preflight/              # Headless Chromium rendering
+    mod.rs
+    browser.rs
+    browser_config.rs
+    chromium.rs
+    cookies.rs
+    preflight_state.rs
+    stealth.rs
+  escalation.rs              # EscalationEngine state machine
+  daemon/
+    main.rs                  # recurld daemon entry point
+    lifecycle.rs             # DaemonLifecycle state machine
+    browser_state.rs         # BrowserState state machine
+    pool.rs                  # Browser instance pooling
+    ipc.rs                   # IPC transport
+  protocol.rs                # IPC message protocol
+  config.rs                  # Configuration & defaults
+  daemon_client.rs           # Daemon client interface
+```
+
+### Running Tests
+
+```bash
+# Unit tests
+cargo test
+
+# All tests including integration
+cargo test --all-features
+```
+
+### Documentation
+
+- [Installation Guide](docs/installation.md) - Platform-specific setup
+- [Architecture](docs/architecture.md) - System design deep-dive
+- [CLI Reference](docs/cli.md) - Complete flag documentation
+- [Escalation Layers](docs/layers.md) - How bypass works
+- [Daemon](docs/daemon.md) - recurld configuration
+- [Compliance Testing](docs/compliance.md) - curl compatibility
+
+## Contributing
+
+Contributions welcome! Please read the architecture docs first to understand the codebase structure.
+
+```bash
+# Fork and clone
+git clone https://github.com/YOUR_USERNAME/recurl
+cd recurl
+
+# Create a branch
+git checkout -b feature/your-feature
+
+# Make changes, then test
+cargo test
+
+# Submit a PR
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+Built by [Neul Labs](https://github.com/neul-labs)

recurl/bin/install.sh

@@ -0,0 +1,229 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# recurl installer for Linux and macOS
+# Usage: curl -fsSL https://recurl.dev/install.sh | bash
+
+VERSION="${RECURL_VERSION:-latest}"
+INSTALL_DIR="${RECURL_INSTALL_DIR:-}"
+GITHUB_REPO="neul-labs/recurl"
+BASE_URL="https://github.com/${GITHUB_REPO}/releases"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+info() { echo -e "${BLUE}[info]${NC} $1"; }
+success() { echo -e "${GREEN}[success]${NC} $1"; }
+warn() { echo -e "${YELLOW}[warn]${NC} $1"; }
+error() { echo -e "${RED}[error]${NC} $1"; exit 1; }
+
+# Detect OS
+detect_os() {
+    case "$(uname -s)" in
+        Linux*)  echo "linux" ;;
+        Darwin*) echo "darwin" ;;
+        *)       error "Unsupported OS: $(uname -s). Use Windows installer for Windows." ;;
+    esac
+}
+
+# Detect architecture
+detect_arch() {
+    case "$(uname -m)" in
+        x86_64|amd64)  echo "x86_64" ;;
+        arm64|aarch64) echo "aarch64" ;;
+        *)             error "Unsupported architecture: $(uname -m)" ;;
+    esac
+}
+
+# Detect shell config file
+detect_shell_config() {
+    local shell_name
+    shell_name=$(basename "$SHELL")
+
+    case "$shell_name" in
+        bash)
+            if [[ -f "$HOME/.bashrc" ]]; then
+                echo "$HOME/.bashrc"
+            elif [[ -f "$HOME/.bash_profile" ]]; then
+                echo "$HOME/.bash_profile"
+            else
+                echo "$HOME/.bashrc"
+            fi
+            ;;
+        zsh)
+            echo "$HOME/.zshrc"
+            ;;
+        fish)
+            echo "$HOME/.config/fish/config.fish"
+            ;;
+        *)
+            echo "$HOME/.profile"
+            ;;
+    esac
+}
+
+# Check if command exists
+has_command() {
+    command -v "$1" &> /dev/null
+}
+
+# Download file
+download() {
+    local url="$1"
+    local output="$2"
+
+    if has_command curl; then
+        curl -fsSL "$url" -o "$output"
+    elif has_command wget; then
+        wget -q "$url" -O "$output"
+    else
+        error "Neither curl nor wget found. Please install one of them."
+    fi
+}
+
+# Get latest version from GitHub
+get_latest_version() {
+    local url="${BASE_URL}/latest"
+    if has_command curl; then
+        curl -fsSL -o /dev/null -w '%{url_effective}' "$url" | rev | cut -d'/' -f1 | rev
+    elif has_command wget; then
+        wget -q -O /dev/null --server-response "$url" 2>&1 | grep -oP 'Location: .*/tag/\K[^/\s]+'
+    fi
+}
+
+# Main installation
+main() {
+    echo ""
+    echo -e "${GREEN}╔═══════════════════════════════════════╗${NC}"
+    echo -e "${GREEN}║         recurl installer               ║${NC}"
+    echo -e "${GREEN}╚═══════════════════════════════════════╝${NC}"
+    echo ""
+
+    # Detect platform
+    local os arch
+    os=$(detect_os)
+    arch=$(detect_arch)
+    info "Detected platform: ${os}-${arch}"
+
+    # Determine version
+    if [[ "$VERSION" == "latest" ]]; then
+        info "Fetching latest version..."
+        VERSION=$(get_latest_version)
+        if [[ -z "$VERSION" ]]; then
+            error "Failed to fetch latest version. Set RECURL_VERSION explicitly."
+        fi
+    fi
+    info "Installing version: ${VERSION}"
+
+    # Determine install directory
+    if [[ -z "$INSTALL_DIR" ]]; then
+        if [[ -w "/usr/local" ]]; then
+            INSTALL_DIR="/usr/local/recurl"
+        else
+            INSTALL_DIR="$HOME/.local/recurl"
+        fi
+    fi
+    info "Install directory: ${INSTALL_DIR}"
+
+    # Create temp directory
+    local tmp_dir
+    tmp_dir=$(mktemp -d)
+    trap "rm -rf $tmp_dir" EXIT
+
+    # Download archive
+    local archive_name="recurl-${os}-${arch}.tar.gz"
+    local download_url="${BASE_URL}/download/${VERSION}/${archive_name}"
+    info "Downloading ${archive_name}..."
+    download "$download_url" "${tmp_dir}/${archive_name}"
+
+    # Extract
+    info "Extracting..."
+    mkdir -p "$INSTALL_DIR"
+    tar -xzf "${tmp_dir}/${archive_name}" -C "$INSTALL_DIR" --strip-components=1
+
+    # Make binaries executable
+    chmod +x "$INSTALL_DIR/recurl"
+    chmod +x "$INSTALL_DIR/recurld"
+    chmod +x "$INSTALL_DIR/bin/"*
+
+    success "recurl installed to ${INSTALL_DIR}"
+    echo ""
+
+    # Verify installation
+    info "Verifying installation..."
+    if "$INSTALL_DIR/recurl" --recurl-debug --version &> /dev/null; then
+        success "recurl binary works correctly"
+    else
+        warn "recurl binary may have issues. Check ${INSTALL_DIR}/recurl"
+    fi
+    echo ""
+
+    # Ask about shell alias
+    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${YELLOW}Shell configuration${NC}"
+    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo ""
+    echo "To use recurl as a drop-in curl replacement, you can:"
+    echo ""
+    echo "  1. Use recurl directly:  recurl https://example.com"
+    echo "  2. Create a shell alias: alias curl='${INSTALL_DIR}/recurl'"
+    echo ""
+
+    local shell_config
+    shell_config=$(detect_shell_config)
+
+    read -p "Add curl alias to ${shell_config}? [y/N] " -n 1 -r
+    echo ""
+
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        # Check if alias already exists
+        if grep -q "alias curl=.*recurl" "$shell_config" 2>/dev/null; then
+            warn "Alias already exists in ${shell_config}"
+        else
+            echo "" >> "$shell_config"
+            echo "# recurl - drop-in curl replacement with anti-bot bypass" >> "$shell_config"
+            echo "alias curl='${INSTALL_DIR}/recurl'" >> "$shell_config"
+            success "Alias added to ${shell_config}"
+        fi
+
+        echo ""
+        info "Run this to apply changes now:"
+        echo ""
+        echo "    source ${shell_config}"
+        echo ""
+    else
+        info "Skipping alias configuration."
+        echo ""
+        echo "To use recurl, either:"
+        echo ""
+        echo "  1. Call recurl directly:"
+        echo "     ${INSTALL_DIR}/recurl https://example.com"
+        echo ""
+        echo "  2. Add to your shell config manually:"
+        echo "     echo \"alias curl='${INSTALL_DIR}/recurl'\" >> ${shell_config}"
+        echo ""
+        echo "  3. Add to PATH:"
+        echo "     export PATH=\"${INSTALL_DIR}:\$PATH\""
+        echo ""
+    fi
+
+    # Final summary
+    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${GREEN}Installation complete!${NC}"
+    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo ""
+    echo "Installed files:"
+    echo "  ${INSTALL_DIR}/recurl        - main binary"
+    echo "  ${INSTALL_DIR}/recurld       - daemon"
+    echo "  ${INSTALL_DIR}/bin/         - curl engines"
+    echo ""
+    echo "Documentation: https://github.com/${GITHUB_REPO}#readme"
+    echo ""
+}
+
+# Run main
+main "$@"

recurl/cli.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""
+CLI entry points for the recurl Python wrapper.
+"""
+
+import sys
+
+from recurl import run, run_daemon
+
+
+def main() -> None:
+    sys.exit(run())
+
+
+def main_daemon() -> None:
+    sys.exit(run_daemon())
+
+
+if __name__ == "__main__":
+    main()

recurl_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: recurl-cli
+Version: 0.1.2
+Summary: Drop-in curl replacement with automatic anti-bot bypass
+License: MIT
+Project-URL: Homepage, https://github.com/neul-labs/recurl
+Project-URL: Repository, https://github.com/neul-labs/recurl
+Project-URL: Documentation, https://docs.neullabs.com/recurl
+Project-URL: Issues, https://github.com/neul-labs/recurl/issues
+Keywords: curl,http,anti-bot,scraping,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# recurl-cli
+
+**Python's missing curl.** Drop-in HTTP client with automatic anti-bot bypass for Python developers, data scientists, and web scrapers.
+
+[![PyPI version](https://img.shields.io/pypi/v/recurl-cli.svg)](https://pypi.org/project/recurl-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/pypi/pyversions/recurl-cli.svg)](https://pypi.org/project/recurl-cli/)
+
+---
+
+## What is recurl?
+
+recurl is a smart drop-in replacement for `curl` that transparently handles bot detection and anti-bot protections used by modern websites. It runs real curl under the hood, detects when a request is blocked (403, captcha, Cloudflare challenge), and automatically escalates through browser impersonation and headless Chromium rendering to get the response you need.
+
+**Same curl syntax. No code changes. It just works.**
+
+```bash
+# Works even on Cloudflare-protected sites
+python -m recurl https://protected-site.com/api/data
+```
+
+## Why Python developers need recurl
+
+If you've ever written Python scripts for web scraping or API access, you've hit these walls:
+
+- `requests.get()` returns **403 Forbidden** on protected sites
+- `urllib` gets blocked by TLS fingerprinting
+- You end up installing Selenium, Playwright, or Puppeteer just to fetch a single page
+- Headless browser setup is heavy, slow, and overkill for simple requests
+
+recurl solves this by being a **curl replacement with built-in escalation**:
+
+1. **First attempt**: Standard curl request (fast, low overhead)
+2. **If blocked**: Retries with browser TLS fingerprint impersonation
+3. **Still blocked**: Launches headless Chromium, solves JS challenges, extracts cookies, replays the request
+
+No Python dependencies for browser automation. No heavy browser setup. Just install and use.
+
+## Installation
+
+### pip (recommended)
+
+```bash
+pip install recurl-cli
+```
+
+### Other package managers
+
+| Platform | Command |
+|----------|---------|
+| **npm** | `npm install -g recurl-cli` |
+| **Homebrew** | `brew tap neul-labs/tap && brew install recurl` |
+| **Cargo** | `cargo install recurl` |
+| **Scoop** | `scoop install recurl` |
+
+See the [full installation guide](https://github.com/neul-labs/recurl#installation) for platform-specific instructions.
+
+## Quick Start
+
+```bash
+# Use as a Python module
+python -m recurl https://api.example.com/data
+
+# Pass through all curl flags
+python -m recurl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' https://api.example.com
+
+# Force JS rendering for heavily protected sites
+python -m recurl --recurl-js https://cloudflare-protected-site.com
+
+# Debug mode to see escalation steps
+python -m recurl --recurl-debug https://example.com
+```
+
+### Python API (coming soon)
+
+```python
+from recurl import fetch
+
+# Simple fetch that handles anti-bot protections automatically
+response = fetch("https://protected-site.com")
+print(response.text)
+```
+
+## Supported Anti-Bot Services
+
+recurl automatically detects and bypasses protection from:
+
+| Service | Detection | Bypass |
+|---------|-----------|--------|
+| Cloudflare | Bot Management, Turnstile, JS Challenge | ✓ |
+| Akamai Bot Manager | Behavioral analysis | ✓ |
+| PerimeterX / HUMAN | Client-side fingerprinting | ✓ |
+| DataDome | Bot Protection | ✓ |
+| Imperva / Incapsula | Challenge pages | ✓ |
+| Kasada | Bot Mitigation | ✓ |
+| AWS WAF Bot Control | Request analysis | ✓ |
+| Shape / F5 | Bot Defense | ✓ |
+| hCaptcha | Challenge widget | ✓ |
+| reCAPTCHA | Challenge widget | ✓ |
+
+## Platform Support
+
+| Platform | Architecture | Impersonation | JS Preflight |
+|----------|-------------|:-------------:|:------------:|
+| Linux | x86_64 | ✓ | ✓ |
+| Linux | aarch64 | ✓ | ✓ |
+| macOS | Apple Silicon | ✓ | ✓ |
+| macOS | Intel | ✓ | ✓ |
+| Windows | x86_64 | — | ✓ |
+
+## CLI Reference
+
+### recurl-specific flags
+
+| Flag | Description |
+|------|-------------|
+| `--recurl-strict` | Disable fallback, pure curl passthrough |
+| `--recurl-impersonate <profile>` | Force TLS fingerprint profile (chrome, firefox, safari) |
+| `--recurl-js` | Force JS preflight (skip straight to Chromium) |
+| `--recurl-js-rendered` | Return rendered DOM instead of raw response |
+| `--recurl-js-wait <selector>` | Wait for CSS selector before capturing |
+| `--recurl-js-timeout <ms>` | JS preflight timeout (default: 30000) |
+| `--recurl-debug` | Show diagnostic output and escalation steps |
+
+All standard curl flags work as expected.
+
+## Use Cases for Python Developers
+
+- **Web scraping** - Extract data from protected sites without Selenium/Playwright overhead
+- **Data pipelines** - Reliable HTTP requests in Airflow, Luigi, or cron jobs
+- **API integration** - Test and call APIs behind bot protection
+- **Research & analytics** - Fetch pricing, inventory, or public datasets
+- **CI/CD** - Reliable HTTP calls in GitHub Actions, GitLab CI, Jenkins
+- **Shell scripting from Python** - Use `subprocess.run(["recurl", ...])` for guaranteed delivery
+
+## How It Works
+
+```
+recurl receives request
+    |
+    +---> curl_engine (real curl binary)
+    |         |
+    |         +---> Success? Return response immediately
+    |         |
+    |         +---> Blocked? (403, 429, captcha, challenge page)
+    |                   |
+    |                   +---> Retry with impersonation (browser TLS fingerprint)
+    |                   |         |
+    |                   |         +---> Success? Return response
+    |                   |         |
+    |                   |         +---> Still blocked?
+    |                   |                   |
+    |                   |                   +---> JS preflight (headless Chromium)
+    |                   |                         |
+    |                   |                         +---> Solve challenge, extract cookies
+    |                   |                         |
+    |                   |                         +---> Replay request with cookies
+    |                   |                               |
+    |                   |                               +---> Return final response
+    |
+    +---> Return result to user
+```
+
+The user sees only the final successful response.
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `RECURL_STRICT=1` | Same as `--recurl-strict` |
+| `RECURL_DEBUG=1` | Enable debug output |
+| `RECURL_DAEMON_IDLE_MS` | Daemon idle timeout (default: 60000) |
+
+### Daemon Mode
+
+The optional `recurld` daemon keeps Chromium warm for sub-second responses:
+
+```bash
+# Start daemon
+recurld start
+
+# Check status
+recurld status
+
+# Stop daemon
+recurld stop
+```
+
+## Links
+
+- **Main Repository**: [github.com/neul-labs/recurl](https://github.com/neul-labs/recurl)
+- **Documentation**: [docs.neullabs.com/recurl](https://docs.neullabs.com/recurl)
+- **Issues**: [github.com/neul-labs/recurl/issues](https://github.com/neul-labs/recurl/issues)
+- **License**: MIT
+
+## Keywords
+
+Python HTTP client, curl replacement, web scraping Python, anti-bot bypass, Cloudflare bypass Python, headless browser Python, TLS fingerprint spoofing, bot detection evasion, requests alternative, urllib replacement, Python CLI tool, data extraction, API client Python, web crawler Python, Chromium automation Python

recurl_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+recurl/__init__.py,sha256=jVoICXp__Jl2C3ENf3PXoP1fEFY-2TiXu44Unvc3Wjc,1509
+recurl/cli.py,sha256=wfzSrwka_v0xagoXtfWud05qOchlIsqA-o4dJgc4dGw,265
+recurl/bin/LICENSE,sha256=yCrr3BbMKoyfUwl7I6QfYNnRO-xKIMriv6WsCn38hY4,1066
+recurl/bin/README.md,sha256=hg4XZivfDWN6ngZNGZFHrto28Gpbatvaf3-piXLUNDo,6453
+recurl/bin/install.sh,sha256=5bGGCfnk9Ilv3cLDNccsj0SObdGobLqOfoEnfydtnkM,7139
+recurl/bin/bin/recurl,sha256=wb6eY2wvmVauXJPFzQpeFEe9555ZZaAriNfluSzKEgU,4038160
+recurl/bin/bin/recurld,sha256=U5o8gDgzIRNBhNYfWydGhVu98pKtmDvkrFCA-_TfsHA,3454448
+recurl_cli-0.1.2.dist-info/METADATA,sha256=ln47sMsSse0kN7x0GS3kh04b_FvwtasxuMVtQNK0T3U,8420
+recurl_cli-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+recurl_cli-0.1.2.dist-info/entry_points.txt,sha256=q07Bzz_IkTNWVAGQ3nwVO4uByDordrCv3aZ3aheA4tE,76
+recurl_cli-0.1.2.dist-info/top_level.txt,sha256=T2lvMOhUoHC2yKVtcxhGyGY24su4WZMjId2kyHY9l-I,7
+recurl_cli-0.1.2.dist-info/RECORD,,

recurl_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

recurl_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+recurl = recurl.cli:main
+recurld = recurl.cli:main_daemon

recurl_cli-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+recurl