@apifuse/provider-sdk 2.1.0-beta.3 → 2.1.0-beta.4

package/src/runtime/tls.ts

@@ -1,434 +0,0 @@
-import { ModuleClient, SessionClient } from "tlsclientwrapper";
-
-import type { ProxyResolutionOptions } from "../config/loader";
-import { resolveProxyConfig } from "../config/loader";
-import { SDKError, TransportError } from "../errors";
-import { getStealthProfile } from "../stealth/profiles";
-import type {
-	CookieJar,
-	TlsClient,
-	TlsFetchOptions,
-	TlsResponse,
-	TlsSession,
-} from "../types";
-
-const DEFAULT_PROFILE = "chrome-146";
-
-const MISSING_PROXY_WARNING =
-	"[provider-sdk] Provider requested proxy routing, but no proxy URL was configured. Continuing without proxy.";
-
-export type TlsClientOptions = ProxyResolutionOptions & {
-	warn?: (message: string) => void;
-	/**
-	 * Proxy-only TLS transport overrides. Use only for upstream proxy products
-	 * that terminate CONNECT with a private CA instead of tunneling the origin
-	 * certificate chain.
-	 */
-	proxyTls?: { insecureSkipVerify?: boolean };
-};
-
-const REMOVED_CHROME_PROFILE_NAMES = new Set([
-	"chrome-120",
-	"chrome-124",
-	"chrome-129",
-	"chrome-130",
-	"chrome-131",
-	"chrome-133",
-	"chrome-144",
-	"chrome-146-psk",
-	"chrome-131-psk",
-	"chrome-130-psk",
-	"edge-131",
-]);
-
-const TLS_PROFILE_MAP: Record<string, string> = {
-	"chrome-146": "chrome_146",
-	"firefox-132": "firefox_132",
-	"firefox-133": "firefox_133",
-	"firefox-135": "firefox_135",
-	"firefox-147": "firefox_147",
-	"safari-15": "safari_15_6_1",
-	"safari-16": "safari_16_0",
-	"ios-safari-17": "safari_ios_17_0",
-	"ios-safari-18": "safari_ios_18_0",
-	"ios-safari-26": "safari_ios_26_0",
-};
-
-type TlsClientWrapperResponse = {
-	status: number;
-	body: string;
-	headers?: Record<string, string>;
-	rawHeaders?: Record<string, string> | [string, string][];
-	usedProtocol?: string;
-	httpVersion?: string;
-	cookies?:
-		| Record<string, { name?: string; value?: string }>
-		| Array<{ name?: string; value?: string }>;
-};
-
-class CookieJarImpl implements CookieJar {
-	private readonly cookies: Record<string, string>;
-
-	constructor(cookieStrings: string[]) {
-		this.cookies = {};
-
-		for (const cookieString of cookieStrings) {
-			const [nameValue] = cookieString.split(";");
-			if (!nameValue) {
-				continue;
-			}
-
-			const separatorIndex = nameValue.indexOf("=");
-			if (separatorIndex === -1) {
-				continue;
-			}
-
-			const name = nameValue.slice(0, separatorIndex).trim();
-			const value = nameValue.slice(separatorIndex + 1).trim();
-			this.cookies[name] = value;
-		}
-	}
-
-	get(name: string): string | undefined {
-		return this.cookies[name];
-	}
-
-	getAll(): Record<string, string> {
-		return { ...this.cookies };
-	}
-
-	toString(): string {
-		return Object.entries(this.cookies)
-			.map(([name, value]) => `${name}=${value}`)
-			.join("; ");
-	}
-
-	find(predicate: (cookie: string) => boolean): string | undefined {
-		for (const [name, value] of Object.entries(this.cookies)) {
-			const cookie = `${name}=${value}`;
-			if (predicate(cookie)) {
-				return cookie;
-			}
-		}
-
-		return undefined;
-	}
-}
-
-function resolveIdentifier(profileName: string): string {
-	if (REMOVED_CHROME_PROFILE_NAMES.has(profileName)) {
-		throw new SDKError(`Unknown stealth profile: ${profileName}`);
-	}
-
-	try {
-		const profile = getStealthProfile(profileName);
-		if (profile.tlsClientIdentifier) {
-			return profile.tlsClientIdentifier;
-		}
-	} catch {
-		// Unknown profile name falls through to static mapping and heuristic.
-	}
-
-	return TLS_PROFILE_MAP[profileName] ?? profileName.replaceAll("-", "_");
-}
-
-function resolveUrl(baseUrl: string, url: string): string {
-	return new URL(url, baseUrl).toString();
-}
-
-function toCookieStrings(
-	response: TlsClientWrapperResponse,
-): string[] | undefined {
-	const cookies = response.cookies;
-	if (!cookies) {
-		return undefined;
-	}
-
-	const values = Array.isArray(cookies) ? cookies : Object.values(cookies);
-	const normalized = values
-		.map((cookie) => {
-			if (!cookie?.name) {
-				return null;
-			}
-
-			return `${cookie.name}=${cookie.value ?? ""}`;
-		})
-		.filter((cookie): cookie is string => cookie !== null);
-
-	return normalized.length > 0 ? normalized : undefined;
-}
-
-function normalizeRawHeaders(
-	rawHeaders: TlsClientWrapperResponse["rawHeaders"],
-	headers: Record<string, string>,
-): [string, string][] {
-	if (Array.isArray(rawHeaders)) {
-		return rawHeaders;
-	}
-
-	if (rawHeaders && typeof rawHeaders === "object") {
-		return Object.entries(rawHeaders);
-	}
-
-	return Object.entries(headers);
-}
-
-export function normalizeResponse(
-	response: TlsClientWrapperResponse,
-): TlsResponse {
-	const headers = response.headers ?? {};
-	const cookies = new CookieJarImpl(toCookieStrings(response) ?? []);
-
-	return {
-		status: response.status,
-		ok: response.status >= 200 && response.status < 300,
-		headers,
-		rawHeaders: normalizeRawHeaders(response.rawHeaders, headers),
-		body: response.body,
-		httpVersion: response.httpVersion ?? response.usedProtocol,
-		cookies,
-		json<T>(): Promise<T> {
-			return Promise.resolve(JSON.parse(response.body) as T);
-		},
-	};
-}
-
-function normalizeBody(body: TlsFetchOptions["body"]): string | null {
-	if (body === undefined) {
-		return null;
-	}
-
-	if (typeof body === "string") {
-		return body;
-	}
-
-	if (Buffer.isBuffer(body)) {
-		return body.toString();
-	}
-
-	return String(body);
-}
-
-async function sendRequest(
-	session: SessionClient,
-	method: string,
-	url: string,
-	options: TlsFetchOptions,
-): Promise<TlsClientWrapperResponse> {
-	const requestOptions = {
-		headers: options.headers,
-		proxy: options.proxy,
-		...(options.headerOrder ? { headerOrder: options.headerOrder } : {}),
-	};
-
-	switch (method) {
-		case "POST":
-			return (await session.post(
-				url,
-				normalizeBody(options.body),
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		case "PUT":
-			return (await session.put(
-				url,
-				normalizeBody(options.body),
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		case "PATCH":
-			return (await session.patch(
-				url,
-				normalizeBody(options.body),
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		case "DELETE":
-			return (await session.delete(
-				url,
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		case "HEAD":
-			return (await session.head(
-				url,
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		case "OPTIONS":
-			return (await session.options(
-				url,
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-		default:
-			return (await session.get(
-				url,
-				requestOptions,
-			)) as TlsClientWrapperResponse;
-	}
-}
-
-function createSessionFetcher(
-	baseUrl: string,
-	defaultProfile: string,
-	moduleClient: ModuleClient,
-	clientOptions: TlsClientOptions,
-): TlsSession {
-	let sessionClient: SessionClient | null = null;
-	let activeProxy: string | undefined;
-	let activeTlsIdentifier: string | undefined;
-	let activeInsecureSkipVerify = false;
-	let hasWarnedMissingProxy = false;
-	const warn = clientOptions.warn ?? console.warn;
-
-	function resolveRequestProxy(options?: TlsFetchOptions): string | undefined {
-		const resolvedProxy = resolveProxyConfig({
-			proxy: options?.proxy ?? clientOptions.proxy,
-			upstream: clientOptions.upstream,
-			apifuseConfig: clientOptions.apifuseConfig,
-		});
-
-		if (resolvedProxy.shouldWarn && !hasWarnedMissingProxy) {
-			hasWarnedMissingProxy = true;
-			warn(MISSING_PROXY_WARNING);
-		}
-
-		return resolvedProxy.url;
-	}
-
-	function closeCurrentSession(): void {
-		const client = sessionClient as
-			| (SessionClient & {
-					destroySession?: () => Promise<unknown>;
-					close?: () => void;
-			  })
-			| null;
-
-		void client?.destroySession?.();
-		client?.close?.();
-		sessionClient = null;
-		activeProxy = undefined;
-		activeTlsIdentifier = undefined;
-		activeInsecureSkipVerify = false;
-	}
-
-	function getSessionClient(
-		profile?: string,
-		proxy?: string,
-		ja3?: string,
-		insecureSkipVerify = false,
-	): SessionClient {
-		const tlsIdentifier = ja3 ?? resolveIdentifier(profile ?? defaultProfile);
-
-		if (
-			!sessionClient ||
-			activeProxy !== proxy ||
-			activeTlsIdentifier !== tlsIdentifier ||
-			activeInsecureSkipVerify !== insecureSkipVerify
-		) {
-			if (sessionClient) {
-				closeCurrentSession();
-			}
-
-			sessionClient = new SessionClient(moduleClient, {
-				tlsClientIdentifier: tlsIdentifier,
-				...(proxy ? { proxyUrl: proxy } : {}),
-				...(insecureSkipVerify ? { insecureSkipVerify: true } : {}),
-				timeoutSeconds: 30,
-			} as ConstructorParameters<typeof SessionClient>[1]);
-			activeProxy = proxy;
-			activeTlsIdentifier = tlsIdentifier;
-			activeInsecureSkipVerify = insecureSkipVerify;
-		}
-
-		return sessionClient;
-	}
-
-	return {
-		async fetch(url, options = {}) {
-			const proxy = resolveRequestProxy(options);
-			const insecureSkipVerify = Boolean(
-				options.tls?.insecureSkipVerify ??
-					(proxy && clientOptions.proxyTls?.insecureSkipVerify),
-			);
-			const session = getSessionClient(
-				options.profile,
-				proxy,
-				options.tls?.ja3,
-				insecureSkipVerify,
-			);
-			const requestUrl = resolveUrl(baseUrl, url);
-
-			try {
-				const method = (options.method ?? "GET").toUpperCase();
-				const response = await sendRequest(session, method, requestUrl, {
-					...options,
-					proxy,
-				});
-
-				if (response.status >= 400 && options.throwOnHttpError !== false) {
-					throw new TransportError(
-						`Upstream request failed with status ${response.status}`,
-						{
-							status: response.status,
-						},
-					);
-				}
-
-				return normalizeResponse(response);
-			} catch (error) {
-				if (error instanceof SDKError || error instanceof TransportError) {
-					throw error;
-				}
-
-				throw new TransportError("Network error", {
-					status: 0,
-					cause: error instanceof Error ? error : undefined,
-				});
-			}
-		},
-		close() {
-			closeCurrentSession();
-		},
-	};
-}
-
-export function createTlsClient(
-	baseUrl: string,
-	defaultProfileOrOptions: string | TlsClientOptions = DEFAULT_PROFILE,
-	clientOptions: TlsClientOptions = {},
-): TlsClient {
-	const defaultProfile =
-		typeof defaultProfileOrOptions === "string"
-			? defaultProfileOrOptions
-			: DEFAULT_PROFILE;
-	const resolvedClientOptions =
-		typeof defaultProfileOrOptions === "string"
-			? clientOptions
-			: defaultProfileOrOptions;
-	const moduleClient = new ModuleClient();
-	let sharedSession: TlsSession | null = null;
-
-	function getSharedSession(): TlsSession {
-		if (!sharedSession) {
-			sharedSession = createSessionFetcher(
-				baseUrl,
-				defaultProfile,
-				moduleClient,
-				resolvedClientOptions,
-			);
-		}
-
-		return sharedSession;
-	}
-
-	return {
-		fetch(url: string, options?: TlsFetchOptions) {
-			return getSharedSession().fetch(url, options);
-		},
-		createSession(opts?: { profile?: string }) {
-			const sessionProfile = opts?.profile ?? defaultProfile;
-			return createSessionFetcher(
-				baseUrl,
-				sessionProfile,
-				moduleClient,
-				resolvedClientOptions,
-			);
-		},
-	};
-}

package/src/types/playwright-stealth.d.ts

@@ -1,9 +0,0 @@
-declare module "playwright-stealth" {
-	export function stealth(page: unknown): Promise<void>;
-
-	const playwrightStealth: {
-		stealth: typeof stealth;
-	};
-
-	export default playwrightStealth;
-}