feat: Add Cloudflare Browser Rendering Plugin

demo/mcp/corsair.ts

@@ -1,6 +1,5 @@
 import 'dotenv/config';
 import { github } from '@corsair-dev/github';
-import { gmail } from '@corsair-dev/gmail';
 import { linear } from '@corsair-dev/linear';
 // import { googlecalendar } from '@corsair-dev/googlecalendar'
 import { slack } from '@corsair-dev/slack';

packages/anthropicadministrator/index.ts

@@ -1,5 +1,4 @@
 import type {
-	AuthTypes,
 	BindEndpoints,
 	CorsairEndpoint,
 	CorsairErrorHandler,

packages/canvas/endpoints/types.ts

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import type { CanvasOperation, CanvasOperationName } from './operations';
 import { canvasOperations } from './operations';
 import type { CanvasEndpointOutputs } from './response-schemas';
-import { CanvasEndpointOutputSchemas } from './response-schemas';
 
 export type {
 	CanvasAccount,

packages/cloudflarebrowserrendering/.vscode/settings.json

@@ -0,0 +1 @@
+{}

packages/cloudflarebrowserrendering/client.ts

@@ -0,0 +1,88 @@
+import type { CloudflareBrowserRenderingContext } from './index';
+
+export class CloudflareBrowserRenderingClient {
+	private ctx: CloudflareBrowserRenderingContext;
+	private baseUrl = 'https://api.cloudflare.com/client/v4';
+
+	constructor(ctx: CloudflareBrowserRenderingContext) {
+		this.ctx = ctx;
+	}
+
+	private async request<T>(path: string, options?: RequestInit): Promise<T> {
+		const apiKey = await this.ctx.keyBuilder('endpoint');
+
+		const response = await fetch(`${this.baseUrl}${path}`, {
+			...options,
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				'Content-Type': 'application/json',
+				...options?.headers,
+			},
+		});
+
+		if (!response.ok) {
+			throw new Error(
+				`Cloudflare API error: ${response.status} ${response.statusText}`,
+			);
+		}
+
+		const data = (await response.json()) as {
+			success: boolean;
+			result: T;
+			errors?: unknown[];
+		};
+
+		if (!data.success) {
+			throw new Error(
+				`Cloudflare API returned errors: ${JSON.stringify(data.errors)}`,
+			);
+		}
+
+		return data.result;
+	}
+
+	async listAccounts() {
+		return this.request<Array<{ id: string; name: string }>>('/accounts');
+	}
+
+	async captureScreenshot(
+		accountId: string,
+		url: string,
+		viewport?: { width: number; height: number },
+	) {
+		return this.request<string>(
+			`/accounts/${accountId}/browser-rendering/screenshot`,
+			{
+				method: 'POST',
+				body: JSON.stringify({ url, viewport }),
+			},
+		);
+	}
+
+	async takeWebpageSnapshot(accountId: string, url: string) {
+		return this.request<{ html: string; screenshot: string }>(
+			`/accounts/${accountId}/browser-rendering/snapshot`,
+			{
+				method: 'POST',
+				body: JSON.stringify({ url }),
+			},
+		);
+	}
+
+	async scrapeHtmlElements(
+		accountId: string,
+		url: string,
+		selectors: string[],
+	) {
+		return this.request<Record<string, unknown>>(
+			`/accounts/${accountId}/browser-rendering/scrape`,
+			{
+				method: 'POST',
+				body: JSON.stringify({
+					url,
+					elements: selectors.map((s) => ({ selector: s })),
+				}),
+			},
+		);
+	}
+}

packages/cloudflarebrowserrendering/endpoints/capture-screenshot.ts

@@ -0,0 +1,20 @@
+import { CloudflareBrowserRenderingClient } from '../client';
+import type { CloudflareBrowserRenderingContext } from '../index';
+import type {
+	CaptureScreenshotCreateInput,
+	CaptureScreenshotCreateResponse,
+} from './types';
+
+export const CaptureScreenshot = {
+	create: async (
+		ctx: CloudflareBrowserRenderingContext,
+		input: CaptureScreenshotCreateInput,
+	): Promise<CaptureScreenshotCreateResponse> => {
+		const client = new CloudflareBrowserRenderingClient(ctx);
+		const viewport =
+			input.viewportWidth && input.viewportHeight
+				? { width: input.viewportWidth, height: input.viewportHeight }
+				: undefined;
+		return client.captureScreenshot(input.accountId, input.url, viewport);
+	},
+};

packages/cloudflarebrowserrendering/endpoints/index.ts

@@ -0,0 +1,4 @@
+export { CaptureScreenshot } from './capture-screenshot';
+export { ListAccounts } from './list-accounts';
+export { ScrapeHtmlElements } from './scrape-html-elements';
+export { TakeWebpageSnapshot } from './take-webpage-snapshot';

packages/cloudflarebrowserrendering/endpoints/list-accounts.ts

@@ -0,0 +1,12 @@
+import { CloudflareBrowserRenderingClient } from '../client';
+import type { CloudflareBrowserRenderingContext } from '../index';
+import type { ListAccountsGetResponse } from './types';
+
+export const ListAccounts = {
+	get: async (
+		ctx: CloudflareBrowserRenderingContext,
+	): Promise<ListAccountsGetResponse> => {
+		const client = new CloudflareBrowserRenderingClient(ctx);
+		return client.listAccounts();
+	},
+};

packages/cloudflarebrowserrendering/endpoints/scrape-html-elements.ts

@@ -0,0 +1,20 @@
+import { CloudflareBrowserRenderingClient } from '../client';
+import type { CloudflareBrowserRenderingContext } from '../index';
+import type {
+	ScrapeHtmlElementsCreateInput,
+	ScrapeHtmlElementsCreateResponse,
+} from './types';
+
+export const ScrapeHtmlElements = {
+	create: async (
+		ctx: CloudflareBrowserRenderingContext,
+		input: ScrapeHtmlElementsCreateInput,
+	): Promise<ScrapeHtmlElementsCreateResponse> => {
+		const client = new CloudflareBrowserRenderingClient(ctx);
+		return client.scrapeHtmlElements(
+			input.accountId,
+			input.url,
+			input.selectors,
+		);
+	},
+};

packages/cloudflarebrowserrendering/endpoints/take-webpage-snapshot.ts

@@ -0,0 +1,16 @@
+import { CloudflareBrowserRenderingClient } from '../client';
+import type { CloudflareBrowserRenderingContext } from '../index';
+import type {
+	TakeWebpageSnapshotCreateInput,
+	TakeWebpageSnapshotCreateResponse,
+} from './types';
+
+export const TakeWebpageSnapshot = {
+	create: async (
+		ctx: CloudflareBrowserRenderingContext,
+		input: TakeWebpageSnapshotCreateInput,
+	): Promise<TakeWebpageSnapshotCreateResponse> => {
+		const client = new CloudflareBrowserRenderingClient(ctx);
+		return client.takeWebpageSnapshot(input.accountId, input.url);
+	},
+};

packages/cloudflarebrowserrendering/endpoints/types.ts

@@ -0,0 +1,106 @@
+import { z } from 'corsair/core';
+
+// --- INPUT SCHEMAS ---
+
+export const ListAccountsGetInputSchema = z.object({}).strict();
+export type ListAccountsGetInput = z.infer<typeof ListAccountsGetInputSchema>;
+
+export const CaptureScreenshotCreateInputSchema = z
+	.object({
+		accountId: z.string().describe('The Cloudflare account ID'),
+		url: z.string().url().describe('The URL to capture'),
+		viewportWidth: z.number().optional().describe('Viewport width in pixels'),
+		viewportHeight: z.number().optional().describe('Viewport height in pixels'),
+	})
+	.strict();
+export type CaptureScreenshotCreateInput = z.infer<
+	typeof CaptureScreenshotCreateInputSchema
+>;
+
+export const TakeWebpageSnapshotCreateInputSchema = z
+	.object({
+		accountId: z.string().describe('The Cloudflare account ID'),
+		url: z.string().url().describe('The URL to snapshot'),
+	})
+	.strict();
+export type TakeWebpageSnapshotCreateInput = z.infer<
+	typeof TakeWebpageSnapshotCreateInputSchema
+>;
+
+export const ScrapeHtmlElementsCreateInputSchema = z
+	.object({
+		accountId: z.string().describe('The Cloudflare account ID'),
+		url: z.string().url().describe('The URL to scrape'),
+		selectors: z
+			.array(z.string())
+			.describe(
+				'Array of CSS selectors to scrape (e.g., ["h1", ".class-name"])',
+			),
+	})
+	.strict();
+export type ScrapeHtmlElementsCreateInput = z.infer<
+	typeof ScrapeHtmlElementsCreateInputSchema
+>;
+
+// --- OUTPUT SCHEMAS ---
+
+export const AccountSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+});
+
+export const ListAccountsGetOutputSchema = z.array(AccountSchema);
+export type ListAccountsGetResponse = z.infer<
+	typeof ListAccountsGetOutputSchema
+>;
+
+export const CaptureScreenshotCreateOutputSchema = z
+	.string()
+	.describe('Base64 encoded screenshot image');
+export type CaptureScreenshotCreateResponse = z.infer<
+	typeof CaptureScreenshotCreateOutputSchema
+>;
+
+export const TakeWebpageSnapshotCreateOutputSchema = z.object({
+	html: z.string().describe('Rendered HTML content of the page'),
+	screenshot: z.string().describe('Base64 encoded screenshot image'),
+});
+export type TakeWebpageSnapshotCreateResponse = z.infer<
+	typeof TakeWebpageSnapshotCreateOutputSchema
+>;
+export const ScrapeHtmlElementsCreateOutputSchema = z
+	.record(z.string(), z.unknown())
+	.describe('Scraped HTML element data from Cloudflare');
+export type ScrapeHtmlElementsCreateResponse = z.infer<
+	typeof ScrapeHtmlElementsCreateOutputSchema
+>;
+
+// --- EXPORTS FOR INDEX.TS ---
+
+export const CloudflareBrowserRenderingEndpointInputSchemas = {
+	listAccountsGet: ListAccountsGetInputSchema,
+	captureScreenshotCreate: CaptureScreenshotCreateInputSchema,
+	takeWebpageSnapshotCreate: TakeWebpageSnapshotCreateInputSchema,
+	scrapeHtmlElementsCreate: ScrapeHtmlElementsCreateInputSchema,
+} as const;
+
+export const CloudflareBrowserRenderingEndpointOutputSchemas = {
+	listAccountsGet: ListAccountsGetOutputSchema,
+	captureScreenshotCreate: CaptureScreenshotCreateOutputSchema,
+	takeWebpageSnapshotCreate: TakeWebpageSnapshotCreateOutputSchema,
+	scrapeHtmlElementsCreate: ScrapeHtmlElementsCreateOutputSchema,
+} as const;
+
+export type CloudflareBrowserRenderingEndpointInputs = {
+	listAccountsGet: ListAccountsGetInput;
+	captureScreenshotCreate: CaptureScreenshotCreateInput;
+	takeWebpageSnapshotCreate: TakeWebpageSnapshotCreateInput;
+	scrapeHtmlElementsCreate: ScrapeHtmlElementsCreateInput;
+};
+
+export type CloudflareBrowserRenderingEndpointOutputs = {
+	listAccountsGet: ListAccountsGetResponse;
+	captureScreenshotCreate: CaptureScreenshotCreateResponse;
+	takeWebpageSnapshotCreate: TakeWebpageSnapshotCreateResponse;
+	scrapeHtmlElementsCreate: ScrapeHtmlElementsCreateResponse;
+};

packages/cloudflarebrowserrendering/error-handlers.ts

@@ -0,0 +1,31 @@
+import type { CorsairErrorHandler } from 'corsair/core';
+import { ApiError } from 'corsair/http';
+
+export const errorHandlers = {
+	RATE_LIMIT_ERROR: {
+		match: (error: Error) => {
+			if (error instanceof ApiError && error.status === 429) return true;
+			const msg = error.message.toLowerCase();
+			return msg.includes('rate_limited') || msg.includes('429');
+		},
+		handler: async (error: Error) => {
+			let retryAfterMs: number | undefined;
+			if (error instanceof ApiError && error.retryAfter !== undefined) {
+				retryAfterMs = error.retryAfter;
+			}
+			return { maxRetries: 5, headersRetryAfterMs: retryAfterMs };
+		},
+	},
+	AUTH_ERROR: {
+		match: (error: Error) => {
+			if (error instanceof ApiError && error.status === 401) return true;
+			const msg = error.message.toLowerCase();
+			return msg.includes('unauthorized') || msg.includes('invalid_auth');
+		},
+		handler: async () => ({ maxRetries: 0 }),
+	},
+	DEFAULT: {
+		match: () => true,
+		handler: async () => ({ maxRetries: 0 }),
+	},
+} satisfies CorsairErrorHandler;