File Downloads

import { connect } from "puppeteer-core";
import { Hyperbrowser } from "@hyperbrowser/sdk";
import { config } from "dotenv";

config();

const client = new Hyperbrowser({
  apiKey: process.env.HYPERBROWSER_API_KEY,
});

async function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function waitForDownload(sessionId, timeout = 15_000) {
  const maxRetries = timeout / 1000;
  let retries = 0;
  while (retries < maxRetries) {
    console.log(
      `Waiting for download zip to be ready... (${retries + 1}/${maxRetries})`
    );
    const downloadsResponse = await client.sessions.getDownloadsURL(sessionId);
    if (
      downloadsResponse.status === "completed" ||
      downloadsResponse.status === "failed"
    ) {
      return downloadsResponse;
    }
    await sleep(1000);
    retries++;
  }
  throw new Error(`Download zip not ready after ${timeout}ms`);
}

async function main() {
  const session = await client.sessions.create({
    saveDownloads: true,
  });
  console.log("Session created:", session.id);

  try {
    const browser = await connect({
      browserWSEndpoint: session.wsEndpoint,
      defaultViewport: null,
    });
    const defaultContext = browser.defaultBrowserContext();
    const page = (await defaultContext.pages())[0];

    const cdp = await browser.target().createCDPSession();
    await cdp.send("Browser.setDownloadBehavior", {
      behavior: "allow",
      downloadPath: "/tmp/downloads",
      eventsEnabled: true,
    });

    await page.goto("https://browser-tests-alpha.vercel.app/api/download-test");

    // Download file from the page
    // Set up download listener
    cdp.on("Browser.downloadWillBegin", (event) => {
      console.log("Download started:", event.suggestedFilename);
    });

    // Create a promise that resolves when the download is complete
    const downloadPromise = new Promise((resolve) => {
      cdp.on("Browser.downloadProgress", (event) => {
        if (event.state === "completed" || event.state === "canceled") {
          resolve("Done");
        }
      });
    });

    // Start the download and wait for it to complete
    await Promise.all([downloadPromise, page.locator("#download").click()]);

    await client.sessions.stop(session.id);

    await sleep(3000);

    // Wait for the zipped downloads to be uploaded to our storage
    const downloadsResponse = await waitForDownload(session.id);

    console.log("downloadsResponse", downloadsResponse);
  } catch (err) {
    console.error(`Encountered error: ${err}`);
  } finally {
    await client.sessions.stop(session.id);
  }
}

main().catch(console.error);

import os
import asyncio
from pyppeteer import connect
from hyperbrowser import AsyncHyperbrowser
from hyperbrowser.models import CreateSessionParams
from dotenv import load_dotenv

load_dotenv()

client = AsyncHyperbrowser(api_key=os.getenv("HYPERBROWSER_API_KEY"))


async def waitForDownload(sessionId, timeout=15_000):
    maxRetries = timeout // 1000
    retries = 0
    while retries < maxRetries:
        print(f"Waiting for download zip to be ready... ({retries + 1}/{maxRetries})")
        downloadsResponse = await client.sessions.get_downloads_url(sessionId)
        if (
            downloadsResponse.status == "completed"
            or downloadsResponse.status == "failed"
        ):
            return downloadsResponse
        await asyncio.sleep(1000)
        retries += 1
    raise Exception(f"Download zip not ready after {timeout}ms")


async def main():
    # Create a session with downloads enabled
    session = await client.sessions.create(CreateSessionParams(save_downloads=True))
    print(f"Session created: {session.id}")

    try:
        # Connect to the browser
        browser = await connect(
            browserWSEndpoint=session.ws_endpoint, defaultViewport=None
        )
        defaultContext = browser._defaultContext

        # Get the first page
        page = await defaultContext.newPage()

        # Get the CDP client
        cdp_client = page._client

        # Configure download behavior
        await cdp_client.send(
            "Browser.setDownloadBehavior",
            {
                "behavior": "allow",
                "downloadPath": "/tmp/downloads",
                "eventsEnabled": True,
            },
        )

        # Navigate to the test page
        await page.goto("https://browser-tests-alpha.vercel.app/api/download-test")

        # Set up download event handlers
        download_completed = asyncio.Event()

        def on_download_begin(event):
            print(f"Download started: {event.get('suggestedFilename', 'unknown')}")

        def on_download_progress(event):
            if event.get("state") in ["completed", "canceled"]:
                download_completed.set()

        cdp_client.on("Browser.downloadWillBegin", on_download_begin)
        cdp_client.on("Browser.downloadProgress", on_download_progress)

        # Start the download by clicking the button
        download_task = asyncio.create_task(download_completed.wait())
        await page.click("#download")

        # Add a timeout to prevent hanging indefinitely
        try:
            await asyncio.wait_for(download_task, timeout=30)
            print("Download completed")
        except asyncio.TimeoutError:
            print("Download timed out after 30 seconds")

        await client.sessions.stop(session.id)

        await asyncio.sleep(3)

        # Wait for downloads to be processed and uploaded
        downloads_response = await waitForDownload(session.id)

        print("downloadsResponse", downloads_response)
    except Exception as err:
        print(f"Encountered error: {err}")
    finally:
        await client.sessions.stop(session.id)


if __name__ == "__main__":
    asyncio.run(main())