HPX

https://github.com/longcipher/hpx
Admin
HPX is a high-performance HTTP client for crypto exchange HFT applications with browser emulation,...
Tokens:207,502
Snippets:2,114
Trust Score:7.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Quick Start HTTP/3 Client

Source: https://github.com/longcipher/hpx/blob/master/docs/http3.md

A basic example demonstrating how to create an HTTP/3-only client and make a GET request. This snippet requires the 'http3' feature to be enabled.

```rust
use hpx::Client;

#[tokio::main]
async fn main() -> hpx::Result<()> {
    let client = Client::builder()
        .http3_only()
        .build()?;

    let resp = client
        .get("https://cloudflare-quic.com/")
        .send()
        .await?;

    println!("Status: {}", resp.status());
    println!("Body: {}", resp.text().await?);
    Ok(())
}
```

--------------------------------

### HTTP/3 integration test setup

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/progress.md

Sets up a local HTTP/3 server with a self-signed certificate and a client configured to trust it. The test then sends a GET request and asserts the response status, version, and body.

```rust
crates/hpx/tests/http3.rs:693-884
// Spins up local h3 server:
// rcgen self-signed cert → rustls ServerConfig with ALPN [b"h3"] → quinn::Endpoint::server → h3::server::Connection → accept → resolve_request → send_response with body `hello, h3`

// Builds client with custom root store (trusting rcgen cert) via `build_quinn_client_config_with_root_store` → constructs `QuicConnector` → `Client::builder().http3_only().__test_with_quic_connector(connector).build()`

// Sends `GET https://127.0.0.1:{port}/hello`

// Asserts:
// response.status() == StatusCode::OK (line 860)
// response.version() == Version::HTTP_3 (line 867)
// body == b"hello, h3" (line 876)
```

--------------------------------

### Add and Start a Download with hpx-dl

Source: https://github.com/longcipher/hpx/blob/master/README.md

Initiates a download for a given URL using the DownloadEngine and starts its execution. Requires the `hpx-dl` crate.

```rust
use hpx_dl::{DownloadEngine, EngineConfig};

let engine = DownloadEngine::new(EngineConfig::default());
let id = engine.add("https://example.com/large-file.bin").await?;
engine.start(id).await?;
```

--------------------------------

### Complete WS-over-h3 Example

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/tasks.md

Fill in the placeholder for the h3_websocket.rs example with a working implementation. This example demonstrates extended CONNECT, H3WebSocket extraction, and text, binary, ping, pong, and close messages.

```rust
cargo run -p hpx --features http3 --example h3_websocket
```

--------------------------------

### Make a GET Request

Source: https://github.com/longcipher/hpx/blob/master/README.md

Demonstrates how to perform a simple GET request and retrieve the response body as text. Requires no special features.

```rust
#[tokio::main]
async fn main() -> hpx::Result<()> {
    let body = hpx::get("https://www.rust-lang.org")
        .send()
        .await?
        .text()
        .await?;

    println!("body = {body:?}");
    Ok(())
}
```

--------------------------------

### Start hpxless CLI Server

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts the CDP server on the default port. Use this for basic headless browser functionality.

```bash
hpxless
```

--------------------------------

### Start Chrome DevTools Protocol Server with hpx CLI

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts a CDP server on a specified port for browser automation.

```bash
hpx serve --port 9222
```

--------------------------------

### Minimal HTTP Client Configuration

Source: https://github.com/longcipher/hpx/blob/master/README.md

Use this configuration for a basic HTTP client setup.

```toml
hpx = "2"
```

--------------------------------

### Start hpxless with Proxy

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts the CDP server on a custom port with stealth mode and configures a SOCKS5 proxy.

```bash
hpxless --port 9222 --stealth --proxy socks5://127.0.0.1:1080
```

--------------------------------

### Start hpxless Server

Source: https://github.com/longcipher/hpx/blob/master/bin/hpxless/README.md

Start the hpxless server on the default port 9222. This command initiates the headless browser server.

```bash
hpxless
```

```bash
hpxless --port 9222 --stealth
```

```bash
hpxless --url https://example.com
```

```bash
hpxless --block images,media
```

```bash
hpxless --proxy socks5://127.0.0.1:1080
```

--------------------------------

### Implement QUIC TLS Path Configuration

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/design.md

Create a new module to build quinn::ClientConfig from TlsOptions and Http3Options, handling rustls configuration and quinn::Endpoint setup.

```rust
// crates/hpx/src/tls/quic.rs (NEW)

// A new module that builds a `quinn::ClientConfig` from the existing `TlsOptions` + the new `Http3Options`. Key responsibilities:

// 1. Convert `rustls::ClientConfig` (already built by `tls/rustls.rs`) to a `rustls::ClientConfig` with the `quic` feature enabled — use `rustls::ClientConfig::builder().quic()?` or build a fresh `ClientConfig` with `enable_early_data = opts.enable_0rtt` and `alpn_protocols = vec![b"h3".into()]`.
// 2. Build a `quinn::TransportConfig` from `Http3Options`'s QUIC fields.
// 3. Build a `quinn::Endpoint` lazily (one per client, bound to `0.0.0.0:0` or a user-supplied local address).

// Ponytail check: reuses the existing `rustls::ClientConfig` builder; the only new code is the QUIC-specific `TransportConfig` mapping and the `quinn::Endpoint` lifecycle.
```

--------------------------------

### Basic GET Request with HPX

Source: https://github.com/longcipher/hpx/blob/master/crates/hpx/README.md

Demonstrates a simple GET request to a URL and prints the response body. Requires the tokio runtime.

```rust
#[tokio::main]
async fn main() -> hpx::Result<()> {
    let body = hpx::get("https://www.rust-lang.org")
        .send()
        .await?;

    println!("body = {:?}", body);
    Ok(())
}
```

--------------------------------

### Download Progress Display Example

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/design.md

Example of how download progress is displayed in the CLI. When not a terminal, one-line status updates are emitted. Uses the 'indicatif' crate for terminal progress bars.

```text
[===           ] 23% 1.2/5.0 MB  256 KB/s  ETA 15s
```

--------------------------------

### Start hpxless with Stealth and Custom Profile

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts the CDP server on a custom port with stealth mode enabled and specifies a browser profile (e.g., Firefox).

```bash
hpxless --port 9222 --stealth --profile firefox
```

--------------------------------

### Run CLI with speed limit

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/tasks.md

Example of running the HPX CLI with the --speed-limit flag to throttle downloads. Verifies that the download speed is approximately as specified.

```bash
cargo run -p hpx-cli -- dl add https://httpbin.org/bytes/10485760 --speed-limit 1MB/s
```

--------------------------------

### Environment Variable Support Example

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/design.md

Illustrates how to support HPX_ prefixed environment variables for CLI flags. This allows configuration via environment variables with specific precedence rules.

```rust
// In cli.rs, after Cli::parse(), merge with env vars
// e.g., HPX_TIMEOUT=30, HPX_HEADERS="Authorization:Bearer token"
```

--------------------------------

### Start hpxless with URL Blocking

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts the CDP server on a custom port and blocks specified URL patterns, useful for preventing ad or tracker loads.

```bash
hpxless --port 9222 --block '*.ads.com,tracker.example.com'
```

--------------------------------

### HPX SSE Transport Public API and Usage Example (Rust)

Source: https://github.com/longcipher/hpx/blob/master/specs/integrate-sse-transport/design.md

Demonstrates the public API surface for the HPX SSE transport and provides a usage example. It shows how to configure an SSE connection, establish it, and process incoming events.

```rust
// Re-exports from sse/mod.rs
pub use config::SseConfig;
pub use connection::{SseConnection, SseConnectionState, SseHandle, SseStream};
pub use protocol::SseProtocolHandler;
pub use types::{SseEvent, SseMessageKind};
pub mod handlers;

// Re-export sseer core types for convenience
pub use sseer::event::Event as RawSseEvent;

```

```rust
use hpx_transport::sse::{SseConfig, SseConnection, SseEvent, handlers::GenericSseHandler};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = SseConfig::new("https://api.exchange.com/v1/stream")
        .connect_timeout(Duration::from_secs(10))
        .reconnect_max_attempts(Some(5));

    let handler = GenericSseHandler::new();
    let client = hpx::Client::builder().build()?;

    let connection = SseConnection::connect(config, handler, client).await?;
    let (handle, mut stream) = connection.split();

    while let Some(event) = stream.next().await {
        println!("Event type: {}, data: {}", event.raw.event, event.raw.data);
    }
    Ok(())
}
```

--------------------------------

### Run CLI with checksum verification

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/tasks.md

Example of running the HPX CLI with the --checksum flag for integrity verification. Verifies that a download with a correct hash succeeds and a mismatch fails.

```bash
cargo run -p hpx-cli -- dl add <url> --checksum sha256:<correct_hash>
```

--------------------------------

### ClientBuilder HTTP/3 Configuration Methods

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/design.md

Provides examples of `ClientBuilder` methods for configuring HTTP/3 behavior. These include forcing HTTP/3, aliasing for familiarity, setting HTTP/3 options, configuring QUIC transport, and enabling opportunistic HTTP/3.

```rust
impl ClientBuilder {
    /// Force HTTP/3 only. Fail if QUIC handshake fails; no fallback.
    pub fn http3_only(mut self) -> Self { self.config.ver_pref = HttpVersionPref::Http3; self }

    /// Alias of `http3_only()` for reqwest API familiarity.
    pub fn http3_prior_knowledge(self) -> Self { self.http3_only() }

    /// Configure QUIC + h3 parameters.
    pub fn http3_options(mut self, opts: impl Into<Http3Options>) -> Self {
        self.config.http3_options = opts.into().into();
        self
    }

    /// Custom QUIC transport configuration (low-level escape hatch).
    pub fn quic_config(mut self, cfg: QuicConfig) -> Self {
        self.config.quic_config = Some(cfg);
        self
    }

    /// Opportunistic HTTP/3 via Alt-Svc, with automatic fallback to h2/h1.
    pub fn prefer_http3(mut self) -> Self {
        self.config.prefer_http3 = true;
        // Implies HttpVersionPref::All (propose h2+h1 over TCP, accept Alt-Svc hints).
        self.config.ver_pref = HttpVersionPref::All;
        self
    }
}
```

--------------------------------

### JSON Output Format Example

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/design.md

Defines the JSON output structure for 'dl list' or 'dl status' commands when the '--format json' flag is used. Provides details on download ID, URL, state, progress, and speed.

```json
[
  {"id": "uuid", "url": "...", "state": "downloading", "progress": 0.23, "speed": 256000}
]
```

--------------------------------

### Fix: Get Owned Frame Payload: Rust

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/UPGRADE_GUIDE.md

Provides solutions for the error 'cannot move out of `frame.payload`' by either cloning the payload reference or using `into_parts()` to get ownership.

```rust
// Option 1: Clone
let payload = frame.payload().clone();

// Option 2: Use into_parts() for ownership
let (opcode, is_fin, payload) = frame.into_parts();
```

--------------------------------

### Implement Connection Entry Point in Rust

Source: https://github.com/longcipher/hpx/blob/master/docs/hpx-actor-tasks.md

Provides the main entry point `Connection::connect` for establishing a new WebSocket connection. It sets up necessary channels, stores, spawns the connection driver task, and returns handles for controlling the connection and receiving events.

```rust
async fn connect(config, handler) -> Result<(ConnectionHandle, ConnectionStream)> {
    // Validate config.
    // Create channels: ctrl_tx/ctrl_rx, cmd_tx/cmd_rx, event_tx/event_rx.
    // Create PendingRequestStore and SubscriptionStore.
    // Spawn connection_driver(...) via tokio::spawn (driver runs connection_task).
    // ...
    // Add event_channel_capacity to WsConfig with default 256.
    // Implement event backpressure policy: Event::Connected/Disconnected use send().await, Event::Message uses try_send (drop + counter/log).
    // ...
    Ok((connection_handle, connection_stream))
}
```

--------------------------------

### Integrate yawc with Axum WebSocket Handler

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/MIGRATION.md

Demonstrates integrating `yawc` with Axum using the `IncomingUpgrade` extractor. This example shows how to handle the WebSocket upgrade request, spawn a task to manage the WebSocket connection, and manually return the response.

```rust
use yawc::{IncomingUpgrade, Options};
use axum::response::Response;

async fn ws_handler(ws: IncomingUpgrade) -> Response {
    let (response, upgrade) = ws
        .upgrade(Options::default())
        .unwrap();

    tokio::spawn(async move {
        let mut ws = upgrade.await.unwrap();

        while let Some(frame) = ws.next().await {
            let _ = ws.send(frame).await;
        }
    });

    response
}

```

--------------------------------

### HPX Client with Full Control and Configuration

Source: https://github.com/longcipher/hpx/blob/master/README.md

Shows how to build an `hpx` client with advanced configuration options, including browser emulation, proxy settings, and a cookie provider. Requires an active async runtime.

```rust
let client = hpx::Client::builder()
    .emulation(BrowserProfile::Chrome)
    .proxy("socks5://127.0.0.1:1080")
    .cookie_provider(Jar::default())
    .build()?;
```

--------------------------------

### Integrate tokio-tungstenite with Axum WebSocket Handler

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/MIGRATION.md

Provides an example of integrating `tokio-tungstenite` with the Axum web framework. It defines a WebSocket handler that upgrades incoming HTTP requests to WebSocket connections and then processes messages by echoing them back to the client.

```rust
use axum::{
    extract::ws::{WebSocketUpgrade, WebSocket},
    response::Response,
};

async fn ws_handler(ws: WebSocketUpgrade) -> Response {
    ws.on_upgrade(|socket| handle_socket(socket))
}

async fn handle_socket(mut socket: WebSocket) {
    while let Some(msg) = socket.recv().await {
        let msg = msg.unwrap();
        socket.send(msg).await.unwrap();
    }
}

```

--------------------------------

### Implement Multi-Runtime Support with Adapters

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/UPGRADE_GUIDE.md

Provides an example of how to adapt yawc for use with alternative async runtimes like `smol` by implementing the necessary `AsyncRead` and `AsyncWrite` traits. This showcases yawc's flexibility beyond tokio.

```rust
// See examples/client_smol.rs for a complete example
use smol::net::TcpStream;

// Implement a simple adapter
struct SmolStream(TcpStream);

impl tokio::io::AsyncRead for SmolStream {
    // Bridge implementation
}

impl tokio::io::AsyncWrite for SmolStream {
    // Bridge implementation
}

```

--------------------------------

### Message Creation and Handling: tokio-tungstenite

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/MIGRATION.md

Shows how to create and handle various WebSocket message types (Text, Binary, Ping, Pong, Close) using the tokio-tungstenite library. It includes examples of constructing messages and pattern matching on received messages.

```rust
use tokio_tungstenite::tungstenite::Message;

// Creating messages
let text = Message::Text("Hello".to_string());
let binary = Message::Binary(vec![1, 2, 3]);
let ping = Message::Ping(vec![]);
let pong = Message::Pong(vec![]);
let close = Message::Close(Some(CloseFrame {
    code: CloseCode::Normal,
    reason: "Goodbye".into(),
}));

// Handling messages
match msg {
    Message::Text(text) => {{ /* ... */ }},
    Message::Binary(data) => {{ /* ... */ }},
    Message::Ping(_) => {{ /* auto-responded */ }},
    Message::Pong(_) => {{ /* ... */ }},
    Message::Close(_) => {{ /* ... */ }},
    Message::Frame(_) => {{ /* raw frame */ }},
}
```

--------------------------------

### Add Test Module with Helper Utilities

Source: https://github.com/longcipher/hpx/blob/master/docs/superpowers/plans/2026-06-07-proxy-fixes.md

Sets up a test module with a helper function to create a mock proxy server that responds with a specified status.

```rust
#[cfg(test)]
mod tests {
    use super::*;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};

    /// Helper to create a mock proxy server that responds with given status
    async fn mock_proxy(
        listener: &tokio::net::TcpListener,
        response: &[u8],
    ) -> tokio::task::JoinHandle<()> {
        let (stream, _) = listener.accept().await.unwrap();
        tokio::spawn(async move {
            let mut stream = stream;
            // Read the CONNECT request
            let mut buf = vec![0u8; 4096];
            let _ = stream.read(&mut buf).await;
            // Send response
            let _ = stream.write_all(response).await;
            // Keep connection alive for potential data transfer
            tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
        })
    }
}
```

--------------------------------

### Build Documentation

Source: https://github.com/longcipher/hpx/blob/master/specs/context.md

Generates project documentation, excluding dependencies and including private items, with warnings enabled.

```bash
RUSTDOCFLAGS="-D warnings" cargo doc --workspace --no-deps --document-private-items
```

--------------------------------

### Chrome Launch Flow

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-07-01-absorb-ferrous-browser-features/design.md

Details the steps involved in launching a new Chrome instance, including finding the executable, allocating a port, and establishing a CDP connection.

```text
Browser::launch(config)
  → find_chrome() — platform-specific path search
  → free_port() — TcpListener::bind("127.0.0.1:0")
  → spawn Chrome with --remote-debugging-port={port}
  → parse stderr for "DevTools listening on ws://..."
  → CdpClient::connect(ws_url)
  → send Target.setAutoAttach
  → return Browser handle

```

--------------------------------

### Simple GET Request with hpx CLI

Source: https://github.com/longcipher/hpx/blob/master/README.md

Performs a simple HTTP GET request to a specified URL using the hpx CLI.

```bash
hpx https://api.example.com/data
```

--------------------------------

### Send GET Request over HTTP/3

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/tasks.md

Demonstrates sending a GET request over HTTP/3 using ClientBuilder and verifying the observed protocol version.

```rust
ClientBuilder::new().http3_only().build().get("https://cloudflare.com/cdn-cgi/trace").await?.version().await == Version::HTTP_3
```

--------------------------------

### Start CDP Server with Stealth and Workers using hpx CLI

Source: https://github.com/longcipher/hpx/blob/master/README.md

Starts a CDP server with stealth mode enabled and a specified number of workers.

```bash
hpx serve --port 9222 --stealth --workers 4
```

--------------------------------

### Remove Logging Feature Flag: TOML

Source: https://github.com/longcipher/hpx/blob/master/crates/yawc/UPGRADE_GUIDE.md

Guides users on removing the deprecated `logging` feature flag from `Cargo.toml` for version 0.3.x.

```toml
# Before
yawc = { version = "0.2", features = ["logging"] }

# After
yawc = "0.3"
```

--------------------------------

### Run All Project Tests

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-28-01-js-stealth-shim/tasks.md

Execute a comprehensive test suite for the entire project using the 'just test-all' command. Verifies the overall stability and correctness.

```bash
just test-all
```

--------------------------------

### Minimal HTTP GET Request with HPX

Source: https://github.com/longcipher/hpx/blob/master/README.md

Demonstrates a minimal HTTP GET request using the `hpx` crate to fetch text content from a URL. Requires an active async runtime.

```rust
let body = hpx::get("https://api.example.com").send().await?.text().await?;
```

--------------------------------

### Connect to WebSocket with hpx CLI

Source: https://github.com/longcipher/hpx/blob/master/README.md

Establishes a WebSocket connection to a specified URL.

```bash
hpx wss://echo.websocket.org
```

--------------------------------

### Connect to hpxless from Puppeteer/Playwright

Source: https://github.com/longcipher/hpx/blob/master/README.md

Provides the WebSocket endpoint for connecting Puppeteer or Playwright to the running hpxless server. No Chrome installation is required.

```bash
# Connect from Puppeteer/Playwright
# browserWSEndpoint: ws://127.0.0.1:9222
```

--------------------------------

### List All Downloads with hpx CLI

Source: https://github.com/longcipher/hpx/blob/master/README.md

Displays a list of all currently managed download tasks.

```bash
hpx dl list
```

--------------------------------

### Generate HPX Documentation with HTTP/3

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/tasks.md

Builds the documentation for the HPX crate, including HTTP/3 specific features, without depending on external crates.

```bash
cargo doc -p hpx --features http3 --no-deps
```

--------------------------------

### Playwright Integration

Source: https://github.com/longcipher/hpx/blob/master/bin/hpxless/README.md

Connect to a running hpxless server using Playwright and navigate to a URL. Ensure Playwright is installed and hpxless is running.

```python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp('http://127.0.0.1:9222')
    context = browser.contexts[0]
    page = context.pages[0]
    page.goto('https://example.com')
    print(page.title())
    browser.close()
```

--------------------------------

### Puppeteer Integration

Source: https://github.com/longcipher/hpx/blob/master/bin/hpxless/README.md

Connect to a running hpxless server using Puppeteer and navigate to a URL. Ensure Puppeteer is installed and hpxless is running.

```javascript
const puppeteer = require('puppeteer-core');

(async () => {
  const browser = await puppeteer.connect({
    browserWSEndpoint: 'ws://127.0.0.1:9222',
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');
  console.log(await page.title());
  await browser.disconnect();
})();
```

--------------------------------

### Run HTTP/3 Throughput Benchmarks

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-19-01-http3-rfc-gap-closure/tasks.md

Executes the HTTP/3 throughput benchmarks for the HPX crate to establish a baseline performance measurement.

```bash
cargo bench -p hpx --features http3 --bench http3_throughput
```

--------------------------------

### Run Page Initialization (Rust)

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-28-01-js-stealth-shim/design.md

Implements the `run_page_init` method in Rust. It executes the global JavaScript function `__hpx_init()` to initialize the stealth shim on the page.

```rust
pub fn run_page_init(&mut self) {
    let _ = self.inner.execute_script(
        "<hpx:page-init>",
        "globalThis.__hpx_init();".to_string(),
    );
}
```

--------------------------------

### Run CI Pipeline

Source: https://github.com/longcipher/hpx/blob/master/specs/context.md

Executes the full Continuous Integration pipeline, including linting, testing, and building documentation.

```bash
just ci
```

--------------------------------

### Locator Methods

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-07-07-01-absorb-ferrous-browser-features/design.md

Defines methods for interacting with a web element identified by a locator, including clicking, typing text, waiting, retrieving inner text, and getting attributes.

```rust
impl Locator {
    pub async fn click(&self) -> Result<(), CdpClientError>;
    pub async fn type_text(&self, text: &str) -> Result<(), CdpClientError>;
    pub async fn wait_for(&self, timeout: Duration) -> Result<(), CdpClientError>;
    pub async fn inner_text(&self) -> Result<String, CdpClientError>;
    pub async fn get_attribute(&self, name: &str) -> Result<Option<String>, CdpClientError>;
}
```

--------------------------------

### Manual Verification of Download Command

Source: https://github.com/longcipher/hpx/blob/master/specs/2026-06-05-01-hpx-cli-enhancement/design.md

Demonstrates how to manually verify the new download functionality with specific options like speed limit, checksum, and progress reporting.

```bash
cargo run -p hpx-cli -- dl add https://example.com/large.bin --speed-limit 1MB/s --checksum sha256:abc123 --progress
```