@bctrl/sdk 1.0.1

package/dist/drivers/puppeteer/generated/http-request.d.ts

@@ -0,0 +1,195 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import type { SimpleRpcSender } from '../../../internal/transport.js';
+import type { PuppeteerContinueRequestOverrides, PuppeteerErrorCode, PuppeteerInitiator, PuppeteerInterceptResolutionState, PuppeteerResourceType, PuppeteerResponseForRequest } from '../types.js';
+import type { HTTPResponseFactory, RemotePuppeteerHTTPResponse } from './http-response.js';
+export type { PuppeteerErrorCode, PuppeteerInterceptResolutionState, PuppeteerContinueRequestOverrides, PuppeteerResponseForRequest, PuppeteerInitiator, } from '../types.js';
+/**
+ * Serialized HTTPRequest data received from the server.
+ * @internal
+ */
+export interface SerializedHTTPRequest {
+    requestId: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    postData?: string;
+    hasPostData?: boolean;
+    resourceType: PuppeteerResourceType;
+    isNavigationRequest: boolean;
+    initiator?: PuppeteerInitiator;
+    redirectChain?: string[];
+    responseId?: string;
+    frameId?: string;
+}
+/**
+ * Factory type for creating RemotePuppeteerHTTPRequest instances.
+ * @internal
+ */
+type HTTPRequestFactory = (requestId: string) => RemotePuppeteerHTTPRequest;
+/**
+ * Factory type for creating RemotePuppeteerFrame instances.
+ * @internal
+ */
+type FrameFactory = (frameId: string) => unknown;
+/**
+ * RemotePuppeteerHTTPRequest - Remote Puppeteer HTTPRequest API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.httprequest
+ */
+export declare class RemotePuppeteerHTTPRequest {
+    private sendRpc;
+    private readonly _requestId;
+    private readonly _factories;
+    constructor(sendRpc: SimpleRpcSender, data: SerializedHTTPRequest, factories: {
+        createRequest?: HTTPRequestFactory;
+        createResponse?: HTTPResponseFactory;
+        createFrame?: FrameFactory;
+    });
+    private _data;
+    private _abortErrorReason?;
+    private _continueRequestOverrides;
+    private _responseForRequest?;
+    private _interceptResolutionState;
+    private _interceptResolutionHandled;
+    private _failureText?;
+    /**
+     * The request ID.
+     * @internal
+     */
+    get id(): string;
+    /**
+     * Aborts a request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.abort
+     */
+    abort(errorCode?: PuppeteerErrorCode, priority?: number): Promise<void>;
+    /**
+     * Continues a request with optional overrides.
+     * @see https://pptr.dev/api/puppeteer.httprequest.continue
+     */
+    continue(overrides?: PuppeteerContinueRequestOverrides, priority?: number): Promise<void>;
+    /**
+     * Adds an async request handler to the processing queue.
+     * @see https://pptr.dev/api/puppeteer.httprequest.enqueueinterceptaction
+     */
+    enqueueInterceptAction(pendingHandler: () => void | PromiseLike<unknown>): Promise<void>;
+    /**
+     * Fulfills a request with the given response.
+     * @see https://pptr.dev/api/puppeteer.httprequest.respond
+     */
+    respond(response: PuppeteerResponseForRequest, priority?: number): Promise<void>;
+    /**
+     * The URL of the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.url
+     */
+    url(): string;
+    /**
+     * The HTTP method used for the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.method
+     */
+    method(): string;
+    /**
+     * HTTP headers associated with the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.headers
+     */
+    headers(): Record<string, string>;
+    /**
+     * True when the request has POST data.
+     * @see https://pptr.dev/api/puppeteer.httprequest.haspostdata
+     */
+    hasPostData(): boolean;
+    /**
+     * The request's post body, if any.
+     * @deprecated Use fetchPostData() instead.
+     * @see https://pptr.dev/api/puppeteer.httprequest.postdata
+     */
+    postData(): string | undefined;
+    /**
+     * The request's resource type.
+     * @see https://pptr.dev/api/puppeteer.httprequest.resourcetype
+     */
+    resourceType(): PuppeteerResourceType;
+    /**
+     * True if the request is driving the current frame's navigation.
+     * @see https://pptr.dev/api/puppeteer.httprequest.isnavigationrequest
+     */
+    isNavigationRequest(): boolean;
+    /**
+     * The initiator of the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.initiator
+     */
+    initiator(): PuppeteerInitiator | undefined;
+    /**
+     * A chain of requests initiated to fetch a resource.
+     * @see https://pptr.dev/api/puppeteer.httprequest.redirectchain
+     */
+    redirectChain(): RemotePuppeteerHTTPRequest[];
+    /**
+     * Access information about the request's failure.
+     * @see https://pptr.dev/api/puppeteer.httprequest.failure
+     */
+    failure(): {
+        errorText: string;
+    } | null;
+    /**
+     * @internal
+     * Set the failure text (called when requestfailed event is received).
+     */
+    setFailure(errorText: string): void;
+    /**
+     * The frame that initiated the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.frame
+     */
+    frame(): unknown | null;
+    /**
+     * A matching HTTPResponse object, or null if not received yet.
+     * @see https://pptr.dev/api/puppeteer.httprequest.response
+     */
+    response(): RemotePuppeteerHTTPResponse | null;
+    /**
+     * The most recent reason for aborting the request.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.aborterrorreason
+     */
+    abortErrorReason(): PuppeteerErrorCode | undefined;
+    /**
+     * The ContinueRequestOverrides that will be used if the interception is allowed to continue.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.continuerequestoverrides
+     */
+    continueRequestOverrides(): PuppeteerContinueRequestOverrides;
+    /**
+     * Awaits pending interception handlers and then decides how to fulfill the request interception.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.finalizeinterceptions
+     */
+    finalizeInterceptions(): Promise<void>;
+    /**
+     * The ResponseForRequest that gets used if the interception is allowed to respond.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.responseforrequest
+     */
+    responseForRequest(): PuppeteerResponseForRequest | undefined;
+    /**
+     * An InterceptResolutionState object describing the current resolution action and priority.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.interceptresolutionstate
+     */
+    interceptResolutionState(): PuppeteerInterceptResolutionState;
+    /**
+     * Is true if the intercept resolution has already been handled.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.isinterceptresolutionhandled
+     */
+    isInterceptResolutionHandled(): boolean;
+    /**
+     * Fetches the POST data for the request from the browser.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.fetchpostdata
+     */
+    fetchPostData(): Promise<string | undefined>;
+}

package/dist/drivers/puppeteer/generated/http-request.js

@@ -0,0 +1,243 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+/**
+ * RemotePuppeteerHTTPRequest - Remote Puppeteer HTTPRequest API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.httprequest
+ */
+export class RemotePuppeteerHTTPRequest {
+    sendRpc;
+    _requestId;
+    _factories;
+    constructor(sendRpc, data, factories) {
+        this.sendRpc = sendRpc;
+        this._requestId = data.requestId;
+        this._factories = factories;
+        this._data = data;
+    }
+    _data;
+    _abortErrorReason;
+    _continueRequestOverrides = {};
+    _responseForRequest;
+    _interceptResolutionState = { action: 'none' };
+    _interceptResolutionHandled = false;
+    _failureText;
+    /**
+     * The request ID.
+     * @internal
+     */
+    get id() {
+        return this._data.requestId;
+    }
+    /**
+     * Aborts a request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.abort
+     */
+    async abort(errorCode, priority) {
+        this._abortErrorReason = errorCode;
+        this._interceptResolutionState = { action: 'abort', priority };
+        this._interceptResolutionHandled = true;
+        await this.sendRpc('request.abort', [this._requestId, errorCode, priority]);
+    }
+    /**
+     * Continues a request with optional overrides.
+     * @see https://pptr.dev/api/puppeteer.httprequest.continue
+     */
+    async continue(overrides, priority) {
+        if (overrides) {
+            this._continueRequestOverrides = { ...this._continueRequestOverrides, ...overrides };
+        }
+        this._interceptResolutionState = { action: 'continue', priority };
+        this._interceptResolutionHandled = true;
+        await this.sendRpc('request.continue', [this._requestId, overrides, priority]);
+    }
+    /**
+     * Adds an async request handler to the processing queue.
+     * @see https://pptr.dev/api/puppeteer.httprequest.enqueueinterceptaction
+     */
+    async enqueueInterceptAction(pendingHandler) {
+        await Promise.resolve(pendingHandler());
+        await this.sendRpc('request.enqueueInterceptAction', [this._requestId]);
+    }
+    /**
+     * Fulfills a request with the given response.
+     * @see https://pptr.dev/api/puppeteer.httprequest.respond
+     */
+    async respond(response, priority) {
+        this._responseForRequest = response;
+        this._interceptResolutionState = { action: 'respond', priority };
+        this._interceptResolutionHandled = true;
+        const rpcResponse = {
+            ...response,
+            body: response.body instanceof Uint8Array
+                ? Buffer.from(response.body).toString('base64')
+                : response.body,
+            bodyIsBase64: response.body instanceof Uint8Array,
+        };
+        await this.sendRpc('request.respond', [this._requestId, rpcResponse, priority]);
+    }
+    /**
+     * The URL of the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.url
+     */
+    url() {
+        return this._data.url;
+    }
+    /**
+     * The HTTP method used for the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.method
+     */
+    method() {
+        return this._data.method;
+    }
+    /**
+     * HTTP headers associated with the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.headers
+     */
+    headers() {
+        return this._data.headers;
+    }
+    /**
+     * True when the request has POST data.
+     * @see https://pptr.dev/api/puppeteer.httprequest.haspostdata
+     */
+    hasPostData() {
+        return this._data.hasPostData ?? !!this._data.postData;
+    }
+    /**
+     * The request's post body, if any.
+     * @deprecated Use fetchPostData() instead.
+     * @see https://pptr.dev/api/puppeteer.httprequest.postdata
+     */
+    postData() {
+        return this._data.postData;
+    }
+    /**
+     * The request's resource type.
+     * @see https://pptr.dev/api/puppeteer.httprequest.resourcetype
+     */
+    resourceType() {
+        return this._data.resourceType;
+    }
+    /**
+     * True if the request is driving the current frame's navigation.
+     * @see https://pptr.dev/api/puppeteer.httprequest.isnavigationrequest
+     */
+    isNavigationRequest() {
+        return this._data.isNavigationRequest;
+    }
+    /**
+     * The initiator of the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.initiator
+     */
+    initiator() {
+        return this._data.initiator;
+    }
+    /**
+     * A chain of requests initiated to fetch a resource.
+     * @see https://pptr.dev/api/puppeteer.httprequest.redirectchain
+     */
+    redirectChain() {
+        if (!this._data.redirectChain || !this._factories?.createRequest) {
+            return [];
+        }
+        return this._data.redirectChain.map((requestId) => this._factories.createRequest(requestId));
+    }
+    /**
+     * Access information about the request's failure.
+     * @see https://pptr.dev/api/puppeteer.httprequest.failure
+     */
+    failure() {
+        if (this._failureText) {
+            return { errorText: this._failureText };
+        }
+        return null;
+    }
+    /**
+     * @internal
+     * Set the failure text (called when requestfailed event is received).
+     */
+    setFailure(errorText) {
+        this._failureText = errorText;
+    }
+    /**
+     * The frame that initiated the request.
+     * @see https://pptr.dev/api/puppeteer.httprequest.frame
+     */
+    frame() {
+        if (!this._data.frameId || !this._factories?.createFrame) {
+            return null;
+        }
+        return this._factories.createFrame(this._data.frameId);
+    }
+    /**
+     * A matching HTTPResponse object, or null if not received yet.
+     * @see https://pptr.dev/api/puppeteer.httprequest.response
+     */
+    response() {
+        if (!this._data.responseId || !this._factories?.createResponse) {
+            return null;
+        }
+        return this._factories.createResponse(this._data.responseId);
+    }
+    /**
+     * The most recent reason for aborting the request.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.aborterrorreason
+     */
+    abortErrorReason() {
+        return this._abortErrorReason;
+    }
+    /**
+     * The ContinueRequestOverrides that will be used if the interception is allowed to continue.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.continuerequestoverrides
+     */
+    continueRequestOverrides() {
+        return this._continueRequestOverrides;
+    }
+    /**
+     * Awaits pending interception handlers and then decides how to fulfill the request interception.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.finalizeinterceptions
+     */
+    async finalizeInterceptions() {
+        await this.sendRpc('request.finalizeInterceptions', []);
+    }
+    /**
+     * The ResponseForRequest that gets used if the interception is allowed to respond.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.responseforrequest
+     */
+    responseForRequest() {
+        return this._responseForRequest;
+    }
+    /**
+     * An InterceptResolutionState object describing the current resolution action and priority.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.interceptresolutionstate
+     */
+    interceptResolutionState() {
+        return this._interceptResolutionState;
+    }
+    /**
+     * Is true if the intercept resolution has already been handled.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.isinterceptresolutionhandled
+     */
+    isInterceptResolutionHandled() {
+        return this._interceptResolutionHandled;
+    }
+    /**
+     * Fetches the POST data for the request from the browser.
+     *
+     * @see https://pptr.dev/api/puppeteer.httprequest.fetchpostdata
+     */
+    async fetchPostData() {
+        return this.sendRpc('request.fetchPostData', []);
+    }
+}

package/dist/drivers/puppeteer/generated/http-response.d.ts

@@ -0,0 +1,142 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import type { SimpleRpcSender } from '../../../internal/transport.js';
+import type { PuppeteerHTTPResponse, PuppeteerRemoteAddress, PuppeteerResourceTiming, PuppeteerSecurityDetails } from '../types.js';
+import type { RemotePuppeteerHTTPRequest } from './http-request.js';
+/**
+ * Factory function type for creating HTTPResponse instances from response ID.
+ * Used when the full response data needs to be fetched lazily.
+ */
+export type HTTPResponseFactory = (responseId: string) => RemotePuppeteerHTTPResponse | null;
+/**
+ * Factory function type for creating HTTPResponse instances from serialized data.
+ * Used when the full response data is already available.
+ */
+export type HTTPResponseDataFactory = (data: PuppeteerHTTPResponse) => RemotePuppeteerHTTPResponse;
+/**
+ * Factory type for creating RemotePuppeteerHTTPRequest instances.
+ * @internal
+ */
+type HTTPRequestFactory = (requestId: string) => RemotePuppeteerHTTPRequest;
+/**
+ * Factory type for creating RemotePuppeteerFrame instances.
+ * @internal
+ */
+type FrameFactory = (frameId: string) => unknown;
+/**
+ * Type guard to check if a value is a serialized HTTPResponse.
+ */
+export declare function isSerializedHTTPResponse(value: unknown): value is PuppeteerHTTPResponse;
+/**
+ * RemotePuppeteerHTTPResponse - Remote Puppeteer HTTPResponse API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.httpresponse
+ */
+export declare class RemotePuppeteerHTTPResponse {
+    private sendRpc;
+    private readonly _responseId;
+    private readonly _factories;
+    constructor(sendRpc: SimpleRpcSender, data: PuppeteerHTTPResponse, factories: {
+        createRequest?: HTTPRequestFactory;
+        createFrame?: FrameFactory;
+    });
+    private _data;
+    /**
+     * The response ID.
+     * @internal
+     */
+    get id(): string;
+    /**
+     * Helper to send RPC calls prefixed with the response ID.
+     * @internal
+     */
+    private rpc;
+    /**
+     * The URL of the response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.url
+     */
+    url(): string;
+    /**
+     * The status code of the response (e.g., 200, 404).
+     * @see https://pptr.dev/api/puppeteer.httpresponse.status
+     */
+    status(): number;
+    /**
+     * The status text of the response (e.g., 'OK', 'Not Found').
+     * @see https://pptr.dev/api/puppeteer.httpresponse.statustext
+     */
+    statusText(): string;
+    /**
+     * An object with HTTP headers associated with the response.
+     * All header names are lowercase.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.headers
+     */
+    headers(): Record<string, string>;
+    /**
+     * True if the response was successful (status in the range 200-299).
+     * @see https://pptr.dev/api/puppeteer.httpresponse.ok
+     */
+    ok(): boolean;
+    /**
+     * True if the response was served from the browser's disk cache.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.fromcache
+     */
+    fromCache(): boolean;
+    /**
+     * True if the response was served by a service worker.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.fromserviceworker
+     */
+    fromServiceWorker(): boolean;
+    /**
+     * The IP address and port number used to connect to the remote server.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.remoteaddress
+     */
+    remoteAddress(): PuppeteerRemoteAddress;
+    /**
+     * Security details if the response was received over HTTPS, null otherwise.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.securitydetails
+     */
+    securityDetails(): PuppeteerSecurityDetails | null;
+    /**
+     * Timing information related to the response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.timing
+     */
+    timing(): PuppeteerResourceTiming | null;
+    /**
+     * Promise which resolves to a buffer with the response body.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.buffer
+     */
+    buffer(): Promise<Buffer>;
+    /**
+     * Promise which resolves to the response body as text.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.text
+     */
+    text(): Promise<string>;
+    /**
+     * Promise which resolves to the response body as JSON.
+     * @throws Error if the response body cannot be parsed as JSON.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.json
+     */
+    json(): Promise<unknown>;
+    /**
+     * Alias for text() - returns the response body as a string.
+     * Note: In real Puppeteer, content() is an internal method.
+     * This is provided for convenience.
+     */
+    content(): Promise<string>;
+    /**
+     * A matching HTTPRequest object for this response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.request
+     */
+    request(): RemotePuppeteerHTTPRequest | null;
+    /**
+     * The Frame that initiated this response, or null if navigating to error pages.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.frame
+     */
+    frame(): unknown | null;
+}
+export {};