@apifuse/provider-sdk 2.2.0-beta.2 → 2.2.0-beta.21

package/dist/stateful-signing.d.ts

@@ -0,0 +1,18 @@
+export declare const STATEFUL_SIGNATURE_HEADER = "x-apifuse-stateful-signature";
+export declare const STATEFUL_TIMESTAMP_HEADER = "x-apifuse-stateful-timestamp";
+export declare const STATEFUL_NONCE_HEADER = "x-apifuse-stateful-nonce";
+export type StatefulSigningInput = {
+    readonly secret: string;
+    readonly timestamp: string;
+    readonly rawBody: string;
+    readonly method: string;
+    readonly path: string;
+    readonly nonce: string;
+};
+export declare function signStatefulRequestBody(input: StatefulSigningInput): string;
+export declare function verifyStatefulRequestSignature(input: StatefulSigningInput & {
+    readonly signature: string;
+}): boolean;
+export declare function statefulSignedHeaders(input: Omit<StatefulSigningInput, "nonce"> & {
+    readonly nonce?: string;
+}): Record<string, string>;

package/dist/stateful-signing.js

@@ -0,0 +1,27 @@
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+export const STATEFUL_SIGNATURE_HEADER = "x-apifuse-stateful-signature";
+export const STATEFUL_TIMESTAMP_HEADER = "x-apifuse-stateful-timestamp";
+export const STATEFUL_NONCE_HEADER = "x-apifuse-stateful-nonce";
+export function signStatefulRequestBody(input) {
+    return `v1=${createHmac("sha256", input.secret)
+        .update(`v1:${input.method.toUpperCase()}:${input.path}:${input.timestamp}:${input.nonce}.${input.rawBody}`)
+        .digest("hex")}`;
+}
+export function verifyStatefulRequestSignature(input) {
+    return safeEqualAscii(input.signature, signStatefulRequestBody(input));
+}
+export function statefulSignedHeaders(input) {
+    const nonce = input.nonce ?? randomUUID();
+    return {
+        [STATEFUL_SIGNATURE_HEADER]: signStatefulRequestBody({ ...input, nonce }),
+        [STATEFUL_TIMESTAMP_HEADER]: input.timestamp,
+        [STATEFUL_NONCE_HEADER]: nonce,
+    };
+}
+function safeEqualAscii(actual, expected) {
+    const actualBytes = Buffer.from(actual);
+    const expectedBytes = Buffer.from(expected);
+    if (actualBytes.byteLength !== expectedBytes.byteLength)
+        return false;
+    return timingSafeEqual(actualBytes, expectedBytes);
+}

package/dist/stealth/profiles.d.ts

@@ -1,4 +1,4 @@
-import type { StealthProfile } from "../types";
+import type { StealthProfile } from "../types.js";
 export declare function generateLayer2Headers(profile: StealthProfile): Record<string, string>;
 export declare function getStealthProfile(name: string): StealthProfile;
 export declare function listStealthProfiles(): string[];

package/dist/stealth/profiles.js

@@ -1,4 +1,4 @@
-import { SDKError } from "../errors";
+import { SDKError } from "../errors.js";
 const CHROMIUM_HEADER_ORDER = [
     ":method",
     ":authority",
@@ -74,12 +74,8 @@ function createProfile(name, definition) {
         tlsClientIdentifier: definition.tlsClientIdentifier,
         ja3: definition.ja3,
         ja4: definition.ja4,
-        h2Settings: definition.h2Settings
-            ? { ...definition.h2Settings }
-            : undefined,
-        headerOrder: definition.headerOrder
-            ? [...definition.headerOrder]
-            : undefined,
+        h2Settings: definition.h2Settings ? { ...definition.h2Settings } : undefined,
+        headerOrder: definition.headerOrder ? [...definition.headerOrder] : undefined,
     };
 }
 function extractBrowserMajorVersion(profile) {
@@ -120,9 +116,7 @@ export function generateLayer2Headers(profile) {
             : `"Chromium";v="${majorVersion}", "Google Chrome";v="${majorVersion}", "Not)A;Brand";v="99"`;
         headers["Sec-Ch-Ua-Platform"] = toPlatformHeaderValue(profile.platform);
         headers["Sec-Ch-Ua-Mobile"] =
-            profile.platform === "android" || profile.platform === "ios"
-                ? "?1"
-                : "?0";
+            profile.platform === "android" || profile.platform === "ios" ? "?1" : "?0";
     }
     return headers;
 }
@@ -252,8 +246,5 @@ export function getStealthProfile(name) {
     };
 }
 export function listStealthProfiles() {
-    return [
-        ...Object.keys(STEALTH_PROFILES),
-        ...Object.keys(STEALTH_PROFILE_ALIASES),
-    ];
+    return [...Object.keys(STEALTH_PROFILES), ...Object.keys(STEALTH_PROFILE_ALIASES)];
 }

package/dist/stream-evidence.d.ts

@@ -0,0 +1,74 @@
+import { type JsonValue } from "./contract-json.js";
+import type { HttpStreamResponse } from "./types.js";
+export declare const STREAM_PREVIEW_BYTES = 4096;
+export declare const STREAM_FINALIZE_TIMEOUT_MS = 30000;
+declare const STREAM_EVIDENCE_HEADER_NAMES: readonly ["content-disposition", "content-length", "content-type"];
+type StreamEvidenceHeaderName = (typeof STREAM_EVIDENCE_HEADER_NAMES)[number];
+export type StreamEvidenceHeaders = Partial<Record<StreamEvidenceHeaderName, string>>;
+export interface StreamEvidenceRequest {
+    ordinal: number;
+    method: string;
+    path: string;
+}
+declare const STREAM_EVIDENCE_REDACTION_REASONS: readonly ["high-entropy-token", "malformed-json", "pem-private-key", "sanitized-preview-too-large", "sanitizer-output-invalid", "sensitive-delimited-column", "textual-xml", "truncated-form", "truncated-json", "undecodable-text"];
+export type StreamEvidenceRedactionReason = (typeof STREAM_EVIDENCE_REDACTION_REASONS)[number];
+export interface StreamEvidenceRecord {
+    __apifuse_stream__: true;
+    status: number;
+    ok: boolean;
+    headers: StreamEvidenceHeaders;
+    body_sha256: string;
+    body_bytes: number;
+    body_preview_base64: string;
+    request?: StreamEvidenceRequest;
+    preview_sanitized?: true;
+    preview_redaction_reason?: StreamEvidenceRedactionReason;
+}
+export type StreamEvidenceReplayResponse = HttpStreamResponse & {
+    evidence_only: true;
+    body_sha256: string;
+    body_bytes: number;
+    preview_sanitized?: true;
+    preview_redaction_reason?: StreamEvidenceRedactionReason;
+};
+export interface StreamEvidenceCapture {
+    response: HttpStreamResponse;
+    getEvidence(): Promise<StreamEvidenceRecord>;
+}
+export type StreamCaptureGroupItem = {
+    kind: "stream";
+    evidence: StreamEvidenceRecord;
+} | {
+    kind: "response";
+    value: JsonValue;
+};
+export interface StreamCaptureGroup {
+    items: StreamCaptureGroupItem[];
+}
+export interface StreamCaptureEnvelope {
+    __apifuse_capture__: true;
+    items: StreamCaptureGroupItem[];
+}
+export type StreamEvidenceCaptureOptions = {
+    requestUrl: string;
+    sanitizeFixture?: (value: JsonValue) => JsonValue;
+    request?: StreamEvidenceRequest;
+    finalizeTimeoutMs?: number;
+};
+export declare function parseStreamEvidenceRecord(value: unknown): StreamEvidenceRecord;
+export declare function isStreamEvidenceRecord(value: unknown): value is StreamEvidenceRecord;
+export declare function findStreamEvidenceRecord(value: unknown): StreamEvidenceRecord | undefined;
+/**
+ * Selects every stream captured by the latest recording invocation, in stream call order.
+ * Evidence without request ordinals uses the legacy latest-record-only behavior.
+ */
+export declare function findStreamEvidenceRecords(value: unknown): StreamEvidenceRecord[];
+/** Returns a tagged latest mixed response group used by evidence-only snapshot replay. */
+export declare function findStreamCaptureGroup(value: unknown): StreamCaptureGroup | undefined;
+/** Creates a discriminated invocation envelope so ordinary arrays cannot mimic capture timelines. */
+export declare function createStreamCaptureEnvelope(items: StreamCaptureGroupItem[]): StreamCaptureEnvelope;
+export declare function isStreamEvidenceReplayResponse(response: HttpStreamResponse): response is StreamEvidenceReplayResponse;
+export declare function captureStreamEvidence(response: HttpStreamResponse, options: StreamEvidenceCaptureOptions): StreamEvidenceCapture;
+export declare function replayStreamEvidence(evidence: StreamEvidenceRecord): StreamEvidenceReplayResponse;
+export declare function hasStreamEvidenceMarker(value: unknown): boolean;
+export {};