Reuse sessions

import puppeteer from "@cloudflare/puppeteer";

const MAX_CONCURRENT_CONTEXTS = 4; // adjust according to average workload

export default {
	async fetch(request, env) {
		const url = new URL(request.url);
		let reqUrl = url.searchParams.get("url") || "https://example.com";
		reqUrl = new URL(reqUrl).toString(); // normalize

		// Start with a random active session, then try the remaining sessions
		const sessionIds = await this.getSessionIds(env.MYBROWSER);
		let browser;
		let launched = false;
		for (const sessionId of sessionIds) {
			try {
				const candidate = await puppeteer.connect(env.MYBROWSER, sessionId);
				try {
					if (await this.hasCapacity(candidate)) {
						browser = candidate;
						break;
					}
				} finally {
					if (candidate !== browser) {
						await candidate.disconnect();
					}
				}
			} catch (e) {
				// The session may have closed after it was listed
				console.log(`Failed to connect to ${sessionId}. Error ${e}`);
			}
		}
		if (!browser) {
			// No active session was available, so launch a new session
			browser = await puppeteer.launch(env.MYBROWSER);
			launched = true;
		}

		const sessionId = browser.sessionId();
		const context = await browser.createBrowserContext();

		try {
			const page = await context.newPage();
			const response = await page.goto(reqUrl);
			const html = await response.text();

			return new Response(
				`${launched ? "Launched" : "Connected to"} ${sessionId} \n-----\n` +
					html,
				{
					headers: {
						"content-type": "text/plain",
					},
				},
			);
		} finally {
			await context.close();
			await browser.disconnect();
		}
	},

	async hasCapacity(browser) {
		const client = await browser.target().createCDPSession();
		try {
			const { browserContextIds } = await client.send(
				"Target.getBrowserContexts",
			);
			return browserContextIds.length < MAX_CONCURRENT_CONTEXTS;
		} finally {
			await client.detach();
		}
	},

	async getSessionIds(endpoint) {
		const sessions = await puppeteer.sessions(endpoint);
		console.log(`Sessions: ${JSON.stringify(sessions)}`);
		if (sessions.length === 0) {
			return [];
		}

		const startIndex = Math.floor(Math.random() * sessions.length);
		return [
			...sessions.slice(startIndex),
			...sessions.slice(0, startIndex),
		].map((session) => session.sessionId);
	},
};

import puppeteer, {
	type ActiveSession,
	type Browser,
	type BrowserWorker,
} from "@cloudflare/puppeteer";

const MAX_CONCURRENT_CONTEXTS = 4; // adjust according to average workload

interface Env {
	MYBROWSER: Fetcher;
}

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const url = new URL(request.url);
		let reqUrl = url.searchParams.get("url") || "https://example.com";
		reqUrl = new URL(reqUrl).toString(); // normalize

		// Start with a random active session, then try the remaining sessions
		const sessionIds = await this.getSessionIds(env.MYBROWSER);
		let browser;
		let launched = false;
		for (const sessionId of sessionIds) {
			try {
				const candidate = await puppeteer.connect(env.MYBROWSER, sessionId);
				try {
					if (await this.hasCapacity(candidate)) {
						browser = candidate;
						break;
					}
				} finally {
					if (candidate !== browser) {
						await candidate.disconnect();
					}
				}
			} catch (e) {
				// The session may have closed after it was listed
				console.log(`Failed to connect to ${sessionId}. Error ${e}`);
			}
		}
		if (!browser) {
			// No active session was available, so launch a new session
			browser = await puppeteer.launch(env.MYBROWSER);
			launched = true;
		}

		const sessionId = browser.sessionId();
		const context = await browser.createBrowserContext();

		try {
			const page = await context.newPage();
			const response = await page.goto(reqUrl);
			const html = await response!.text();

			return new Response(
				`${launched ? "Launched" : "Connected to"} ${sessionId} \n-----\n` +
					html,
				{
					headers: {
						"content-type": "text/plain",
					},
				},
			);
		} finally {
			await context.close();
			await browser.disconnect();
		}
	},

	async hasCapacity(browser: Browser): Promise<boolean> {
		const client = await browser.target().createCDPSession();
		try {
			const { browserContextIds } = await client.send(
				"Target.getBrowserContexts",
			);
			return browserContextIds.length < MAX_CONCURRENT_CONTEXTS;
		} finally {
			await client.detach();
		}
	},

	async getSessionIds(endpoint: BrowserWorker): Promise<string[]> {
		const sessions: ActiveSession[] = await puppeteer.sessions(endpoint);
		console.log(`Sessions: ${JSON.stringify(sessions)}`);
		if (sessions.length === 0) {
			return [];
		}

		const startIndex = Math.floor(Math.random() * sessions.length);
		return [
			...sessions.slice(startIndex),
			...sessions.slice(0, startIndex),
		].map((session) => session.sessionId);
	},
};