@apifuse/provider-sdk 2.2.0-beta.3 → 2.2.0-beta.31

package/dist/runtime/stealth-cookies.js

@@ -0,0 +1,111 @@
+import { Cookie, CookieJar as ToughCookieJar } from "tough-cookie";
+import { SDKError, StealthCookieStoreVersionError } from "../errors.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+const LEGACY_COOKIE_ORIGIN = "https://legacy-cookie.invalid/";
+export class StealthCookieJar {
+    cookies;
+    defaultUrl;
+    constructor(cookieStrings, defaultUrl = LEGACY_COOKIE_ORIGIN) {
+        this.cookies = new ToughCookieJar(undefined, {
+            allowSecureOnLocal: false,
+            rejectPublicSuffixes: true,
+        });
+        this.defaultUrl = this.normalizeUrl(defaultUrl) ?? LEGACY_COOKIE_ORIGIN;
+        this.setFromCookieStrings(cookieStrings);
+    }
+    setFromCookieStrings(cookieStrings, url = this.defaultUrl) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return;
+        for (const cookieString of cookieStrings) {
+            this.cookies.setCookieSync(cookieString, cookieUrl, { ignoreError: true });
+        }
+    }
+    get(name, url) {
+        return this.getAll(url)[name];
+    }
+    getAll(url) {
+        return Object.fromEntries(this.getUniqueCookies(url ?? this.defaultUrl).map((cookie) => [cookie.key, cookie.value]));
+    }
+    has(name, url) {
+        return Object.hasOwn(this.getAll(url), name);
+    }
+    toString(url) {
+        return this.getUniqueCookies(url ?? this.defaultUrl)
+            .map((cookie) => cookie.cookieString())
+            .join("; ");
+    }
+    toHeader(url) {
+        return this.toString(url);
+    }
+    snapshot() {
+        const entries = [];
+        for (const cookie of this.serialize().jar.cookies) {
+            if (typeof cookie.key === "string" && typeof cookie.value === "string" && cookie.key) {
+                entries.push([cookie.key, cookie.value]);
+            }
+        }
+        return Object.fromEntries(entries);
+    }
+    restore(cookies) {
+        this.clear();
+        for (const [name, value] of Object.entries(cookies)) {
+            if (!name)
+                continue;
+            this.cookies.setCookieSync(new Cookie({ key: name, path: "/", value }), this.defaultUrl, {
+                ignoreError: true,
+            });
+        }
+    }
+    serialize() {
+        const jar = this.cookies.serializeSync();
+        if (!jar) {
+            throw new SDKError("Stealth cookie store could not be serialized", {
+                code: "stealth_cookie_store_serialize_failed",
+            });
+        }
+        return { version: 1, jar };
+    }
+    deserialize(state) {
+        const version = isRecord(state) ? state.version : undefined;
+        if (version !== 1) {
+            throw new StealthCookieStoreVersionError(version);
+        }
+        const restored = ToughCookieJar.deserializeSync(state.jar);
+        Reflect.set(restored, "allowSecureOnLocal", false);
+        this.cookies = restored;
+    }
+    clear() {
+        this.cookies.removeAllCookiesSync();
+    }
+    find(predicate, url) {
+        for (const cookie of this.getUniqueCookies(url ?? this.defaultUrl)) {
+            const cookieString = cookie.cookieString();
+            if (predicate(cookieString))
+                return cookieString;
+        }
+        return undefined;
+    }
+    normalizeUrl(url) {
+        try {
+            return new URL(url).toString();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getUniqueCookies(url) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return [];
+        const names = new Set();
+        return this.cookies.getCookiesSync(cookieUrl).filter((cookie) => {
+            if (names.has(cookie.key))
+                return false;
+            names.add(cookie.key);
+            return true;
+        });
+    }
+}

package/dist/runtime/stealth.d.ts

@@ -1,6 +1,7 @@
-import type { ImpitResponse } from "impit";
-import type { ProxyResolutionOptions } from "../config/loader";
-import type { StealthClient, StealthResponse } from "../types";
+import type { BrowserProfile, EmulationOS } from "wreq-js";
+import type { ProxyResolutionOptions } from "../config/loader.js";
+import type { StealthClient, StealthResponse } from "../types.js";
+export declare const DEFAULT_PROFILE = "chrome-146";
 export type StealthClientOptions = ProxyResolutionOptions & {
     warn?: (message: string) => void;
     /**
@@ -12,10 +13,34 @@ export type StealthClientOptions = ProxyResolutionOptions & {
         insecureSkipVerify?: boolean;
     };
 };
-type StealthTransportResponse = Pick<ImpitResponse, "arrayBuffer" | "headers" | "json" | "ok" | "status" | "text"> & {
+type StealthTransportHeaders = {
+    entries(): IterableIterator<[string, string]>;
+    get(name: string): string | null;
+    getSetCookie?: () => string[];
+};
+type StealthTransportBody = {
+    cancel(): Promise<void>;
+    getReader(): {
+        read(): Promise<{
+            done: boolean;
+            value?: Uint8Array;
+        }>;
+        cancel(): Promise<void>;
+        releaseLock(): void;
+    };
+};
+type StealthTransportResponse = {
+    arrayBuffer(): Promise<ArrayBuffer>;
+    headers: StealthTransportHeaders;
+    status: number;
+    body?: StealthTransportBody | null;
     url?: string;
     redirected?: boolean;
 };
-export declare function normalizeResponse(response: StealthTransportResponse, requestUrl?: string): Promise<StealthResponse>;
+export declare function resolveWreqProfile(profileName: string, wreqProfiles: readonly BrowserProfile[]): {
+    browser: BrowserProfile;
+    os: EmulationOS;
+};
+export declare function normalizeResponse(response: StealthTransportResponse, requestUrl?: string, maxBodyBytes?: number): Promise<StealthResponse>;
 export declare function createStealthClient(baseUrl: string, defaultProfileOrOptions?: string | StealthClientOptions, clientOptions?: StealthClientOptions): StealthClient;
 export {};