recker 1.0.43 → 1.0.44

package/dist/browser/cache.d.ts

@@ -1,40 +1,2 @@
-export interface CacheEntry<T = unknown> {
-    key: string;
-    value: T;
-    createdAt: number;
-    expiresAt?: number;
-    etag?: string;
-    lastModified?: string;
-}
-export interface BrowserCacheOptions {
-    dbName?: string;
-    storeName?: string;
-    defaultTTL?: number;
-    maxEntries?: number;
-}
-export declare class IndexedDBStorage {
-    private dbName;
-    private storeName;
-    private defaultTTL;
-    private maxEntries;
-    private db;
-    private initPromise;
-    constructor(options?: BrowserCacheOptions);
-    init(): Promise<void>;
-    get<T = unknown>(key: string): Promise<CacheEntry<T> | null>;
-    set<T = unknown>(key: string, value: T, ttl?: number, metadata?: {
-        etag?: string;
-        lastModified?: string;
-    }): Promise<void>;
-    delete(key: string): Promise<boolean>;
-    has(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    keys(): Promise<string[]>;
-    size(): Promise<number>;
-    cleanup(): Promise<number>;
-    private enforceMaxEntries;
-    close(): void;
-    destroy(): Promise<void>;
-}
-export declare function isIndexedDBAvailable(): boolean;
-export declare function getBrowserCacheStorage(options?: BrowserCacheOptions): IndexedDBStorage | null;
+export { IndexedDBStorage } from '../cache/indexed-db.js';
+export { ServiceWorkerCache } from '../cache/service-worker-cache.js';

package/dist/browser/cache.js

@@ -1,199 +1,2 @@
-export class IndexedDBStorage {
-    dbName;
-    storeName;
-    defaultTTL;
-    maxEntries;
-    db = null;
-    initPromise = null;
-    constructor(options = {}) {
-        this.dbName = options.dbName ?? 'recker-cache';
-        this.storeName = options.storeName ?? 'responses';
-        this.defaultTTL = options.defaultTTL ?? 5 * 60 * 1000;
-        this.maxEntries = options.maxEntries ?? 1000;
-    }
-    async init() {
-        if (this.db)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = new Promise((resolve, reject) => {
-            const request = indexedDB.open(this.dbName, 1);
-            request.onerror = () => {
-                reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
-            };
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.storeName)) {
-                    const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
-                    store.createIndex('expiresAt', 'expiresAt', { unique: false });
-                }
-            };
-        });
-        return this.initPromise;
-    }
-    async get(key) {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.get(key);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                const entry = request.result;
-                if (!entry) {
-                    resolve(null);
-                    return;
-                }
-                if (entry.expiresAt && entry.expiresAt < Date.now()) {
-                    this.delete(key).catch(() => { });
-                    resolve(null);
-                    return;
-                }
-                resolve(entry);
-            };
-        });
-    }
-    async set(key, value, ttl, metadata) {
-        await this.init();
-        const entry = {
-            key,
-            value,
-            createdAt: Date.now(),
-            expiresAt: ttl !== undefined ? Date.now() + ttl : undefined,
-            etag: metadata?.etag,
-            lastModified: metadata?.lastModified,
-        };
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.put(entry);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-            transaction.oncomplete = () => {
-                this.enforceMaxEntries().catch(() => { });
-            };
-        });
-    }
-    async delete(key) {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.delete(key);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(true);
-        });
-    }
-    async has(key) {
-        const entry = await this.get(key);
-        return entry !== null;
-    }
-    async clear() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.clear();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-        });
-    }
-    async keys() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.getAllKeys();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(request.result);
-        });
-    }
-    async size() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.count();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(request.result);
-        });
-    }
-    async cleanup() {
-        await this.init();
-        const now = Date.now();
-        let removed = 0;
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const index = store.index('expiresAt');
-            const range = IDBKeyRange.upperBound(now);
-            const request = index.openCursor(range);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    cursor.delete();
-                    removed++;
-                    cursor.continue();
-                }
-            };
-            transaction.oncomplete = () => resolve(removed);
-        });
-    }
-    async enforceMaxEntries() {
-        const currentSize = await this.size();
-        if (currentSize <= this.maxEntries)
-            return;
-        const toRemove = currentSize - this.maxEntries;
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const index = store.index('expiresAt');
-            let removed = 0;
-            const request = index.openCursor();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor && removed < toRemove) {
-                    cursor.delete();
-                    removed++;
-                    cursor.continue();
-                }
-            };
-            transaction.oncomplete = () => resolve();
-        });
-    }
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            this.initPromise = null;
-        }
-    }
-    async destroy() {
-        this.close();
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(this.dbName);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-        });
-    }
-}
-export function isIndexedDBAvailable() {
-    try {
-        return typeof indexedDB !== 'undefined' && indexedDB !== null;
-    }
-    catch {
-        return false;
-    }
-}
-export function getBrowserCacheStorage(options) {
-    if (isIndexedDBAvailable()) {
-        return new IndexedDBStorage(options);
-    }
-    return null;
-}
+export { IndexedDBStorage } from '../cache/indexed-db.js';
+export { ServiceWorkerCache } from '../cache/service-worker-cache.js';

package/dist/browser/constants/user-agents.d.ts

@@ -0,0 +1,7 @@
+export declare const USER_AGENTS: {
+    ANDROID: string;
+    IOS: string;
+    CHROME_WIN: string;
+    CHROME_MAC: string;
+    FIREFOX_MAC: string;
+};

package/dist/browser/constants/user-agents.js

@@ -0,0 +1,7 @@
+export const USER_AGENTS = {
+    ANDROID: 'Mozilla/5.0 (Linux; Android 11; SAMSUNG SM-G973U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/14.2 Chrome/87.0.4280.141 Mobile Safari/537.36',
+    IOS: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/604.1',
+    CHROME_WIN: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    CHROME_MAC: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    FIREFOX_MAC: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/115.0'
+};

package/dist/browser/core/client.d.ts

@@ -28,6 +28,7 @@ export declare class Client {
     private middlewares;
     private hooks;
     private transport;
+    private curlTransport?;
     private defaultHeaders;
     private defaultParams;
     private paginationConfig?;
@@ -49,6 +50,7 @@ export declare class Client {
     private setupCookieJar;
     private createCookieMiddleware;
     private splitSetCookieHeader;
+    private dispatch;
     private composeMiddlewares;
     private hooksMiddleware;
     private httpErrorMiddleware;

package/dist/browser/core/client.js

@@ -2,6 +2,7 @@ import { consoleLogger } from '../types/index.js';
 import { ClientAIImpl } from '../ai/client-ai.js';
 import { HttpRequest } from './request.js';
 import { UndiciTransport } from '../transport/undici.js';
+import { CurlTransport } from '../transport/curl.js';
 import { RequestPromise } from './request-promise.js';
 import { HttpError, MaxSizeExceededError, ConfigurationError, ValidationError, TimeoutError } from '../core/errors.js';
 import { processBody, createFormData, isPlainObject } from '../utils/body.js';
@@ -41,6 +42,7 @@ export class Client {
     middlewares;
     hooks;
     transport;
+    curlTransport;
     defaultHeaders;
     defaultParams;
     paginationConfig;
@@ -88,7 +90,14 @@ export class Client {
         if (options.transport) {
             this.transport = options.transport;
         }
+        else if (options.useCurl) {
+            if (this.debugEnabled)
+                console.log('[DEBUG] Using Curl Transport');
+            this.transport = new CurlTransport();
+        }
         else {
+            if (this.debugEnabled)
+                console.log('[DEBUG] Using Undici Transport');
             let http2Options;
             if (options.http2) {
                 if (typeof options.http2 === 'boolean') {
@@ -281,9 +290,18 @@ export class Client {
     splitSetCookieHeader(header) {
         return header.split(/,(?=\s*[a-zA-Z0-9_-]+=)/g).map(s => s.trim());
     }
+    async dispatch(req) {
+        if (req.useCurl && !(this.transport instanceof CurlTransport)) {
+            if (!this.curlTransport) {
+                this.curlTransport = new CurlTransport();
+            }
+            return this.curlTransport.dispatch(req);
+        }
+        return this.transport.dispatch(req);
+    }
     composeMiddlewares() {
         const chain = [...this.middlewares];
-        const transportDispatch = this.transport.dispatch.bind(this.transport);
+        const transportDispatch = this.dispatch.bind(this);
         if (this.hooks.beforeRequest?.length || this.hooks.afterResponse?.length) {
             chain.unshift(this.hooksMiddleware);
         }

package/dist/browser/index.d.ts

@@ -4,6 +4,7 @@ export * from '../core/client.js';
 export * from '../core/request.js';
 export * from '../core/response.js';
 export * from '../transport/fetch.js';
+export * from '../transport/worker.js';
 export * from '../plugins/retry.js';
 export * from '../plugins/rate-limit.js';
 export * from '../plugins/dedup.js';
@@ -18,12 +19,19 @@ export * from '../plugins/jsonrpc.js';
 export * from '../plugins/grpc-web.js';
 export * from '../plugins/soap.js';
 export * from '../plugins/odata.js';
+export * from '../plugins/har-recorder.js';
+export * from '../plugins/network-simulation.js';
 export * from '../plugins/auth.js';
 export * from '../cache/memory-storage.js';
+export * from '../cache/indexed-db.js';
 export * from '../utils/body.js';
 export * from '../utils/header-parser.js';
 export * from '../utils/link-header.js';
+export * from '../utils/user-agent.js';
 export * from '../utils/charset.js';
+export * from '../seo/analyzer.js';
+export * as ai from '../ai/index.js';
+export * as presets from '../presets/index.js';
 export * from '../constants/http-status.js';
 export * from './crypto.js';
 export * from './cache.js';

package/dist/browser/index.js

@@ -4,6 +4,7 @@ export * from '../core/client.js';
 export * from '../core/request.js';
 export * from '../core/response.js';
 export * from '../transport/fetch.js';
+export * from '../transport/worker.js';
 export * from '../plugins/retry.js';
 export * from '../plugins/rate-limit.js';
 export * from '../plugins/dedup.js';
@@ -18,12 +19,19 @@ export * from '../plugins/jsonrpc.js';
 export * from '../plugins/grpc-web.js';
 export * from '../plugins/soap.js';
 export * from '../plugins/odata.js';
+export * from '../plugins/har-recorder.js';
+export * from '../plugins/network-simulation.js';
 export * from '../plugins/auth.js';
 export * from '../cache/memory-storage.js';
+export * from '../cache/indexed-db.js';
 export * from '../utils/body.js';
 export * from '../utils/header-parser.js';
 export * from '../utils/link-header.js';
+export * from '../utils/user-agent.js';
 export * from '../utils/charset.js';
+export * from '../seo/analyzer.js';
+export * as ai from '../ai/index.js';
+export * as presets from '../presets/index.js';
 export * from '../constants/http-status.js';
 export * from './crypto.js';
 export * from './cache.js';

package/dist/browser/plugins/har-recorder.d.ts

@@ -0,0 +1,40 @@
+import { Plugin } from '../types/index.js';
+interface HarEntry {
+    startedDateTime: string;
+    time: number;
+    request: any;
+    response: any;
+    timings: any;
+    cache: {};
+}
+export declare class HarRecorder {
+    private entries;
+    private isRecording;
+    private onEntry?;
+    start(): void;
+    stop(): void;
+    clear(): void;
+    getEntries(): HarEntry[];
+    setOnEntry(cb: (entry: HarEntry) => void): void;
+    generateHar(): {
+        log: {
+            version: string;
+            creator: {
+                name: string;
+                version: string;
+            };
+            pages: never[];
+            entries: HarEntry[];
+        };
+    };
+    download(filename?: string): void;
+    save(path: string): Promise<void>;
+    plugin(): Plugin;
+    private mapHeaders;
+}
+export declare const harRecorder: HarRecorder;
+export declare const harRecorderPlugin: (options?: {
+    path?: string;
+    onEntry?: (entry: any) => void;
+}) => Plugin;
+export {};

package/dist/browser/plugins/har-recorder.js

@@ -0,0 +1,120 @@
+export class HarRecorder {
+    entries = [];
+    isRecording = false;
+    onEntry;
+    start() {
+        this.isRecording = true;
+        this.entries = [];
+    }
+    stop() {
+        this.isRecording = false;
+    }
+    clear() {
+        this.entries = [];
+    }
+    getEntries() {
+        return this.entries;
+    }
+    setOnEntry(cb) {
+        this.onEntry = cb;
+    }
+    generateHar() {
+        return {
+            log: {
+                version: '1.2',
+                creator: { name: 'Recker', version: '1.0.0' },
+                pages: [],
+                entries: this.entries
+            }
+        };
+    }
+    download(filename = 'recker-session.har') {
+        if (typeof Blob === 'undefined' || typeof document === 'undefined') {
+            throw new Error('download() is only supported in browser. Use save() in Node.js');
+        }
+        const har = this.generateHar();
+        const blob = new Blob([JSON.stringify(har, null, 2)], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+    async save(path) {
+        if (typeof window !== 'undefined') {
+            throw new Error('save() is only supported in Node.js. Use download() in browser');
+        }
+        try {
+            const fs = await import('node:fs/promises');
+            const har = this.generateHar();
+            await fs.writeFile(path, JSON.stringify(har, null, 2));
+        }
+        catch (e) {
+            throw new Error(`Failed to save HAR: ${e.message}`);
+        }
+    }
+    plugin() {
+        return (client) => {
+            if (!client.hooks.afterResponse)
+                client.hooks.afterResponse = [];
+            client.hooks.afterResponse.push(async (req, res) => {
+                if (!this.isRecording)
+                    return;
+                const entry = {
+                    startedDateTime: new Date().toISOString(),
+                    time: res.timings?.total || 0,
+                    request: {
+                        method: req.method,
+                        url: req.url,
+                        httpVersion: "HTTP/1.1",
+                        headers: this.mapHeaders(req.headers),
+                        queryString: [],
+                        cookies: [],
+                        headersSize: -1,
+                        bodySize: -1,
+                    },
+                    response: {
+                        status: res.status,
+                        statusText: res.statusText,
+                        httpVersion: "HTTP/1.1",
+                        headers: this.mapHeaders(res.headers),
+                        cookies: [],
+                        content: {
+                            size: -1,
+                            mimeType: res.headers.get('content-type') || '',
+                            text: "[Body capture disabled]"
+                        },
+                        redirectURL: "",
+                        headersSize: -1,
+                        bodySize: -1,
+                    },
+                    cache: {},
+                    timings: {
+                        send: 0,
+                        wait: res.timings?.firstByte || 0,
+                        receive: (res.timings?.total || 0) - (res.timings?.firstByte || 0)
+                    }
+                };
+                this.entries.push(entry);
+                this.onEntry?.(entry);
+                return res;
+            });
+        };
+    }
+    mapHeaders(headers) {
+        const arr = [];
+        headers.forEach((value, key) => arr.push({ name: key, value }));
+        return arr;
+    }
+}
+export const harRecorder = new HarRecorder();
+export const harRecorderPlugin = (options) => {
+    harRecorder.start();
+    if (options?.onEntry) {
+        harRecorder.setOnEntry(options.onEntry);
+    }
+    return harRecorder.plugin();
+};

package/dist/browser/plugins/network-simulation.d.ts

@@ -0,0 +1,7 @@
+import { Middleware } from '../types/index.js';
+export interface NetworkSimulationOptions {
+    latency?: number;
+    errorRate?: number;
+    errorMessage?: string;
+}
+export declare function simulateNetwork(options: NetworkSimulationOptions): Middleware;

package/dist/browser/plugins/network-simulation.js

@@ -0,0 +1,13 @@
+export function simulateNetwork(options) {
+    return async (req, next) => {
+        if (options.latency && options.latency > 0) {
+            await new Promise(resolve => setTimeout(resolve, options.latency));
+        }
+        if (options.errorRate && options.errorRate > 0) {
+            if (Math.random() < options.errorRate) {
+                throw new Error(options.errorMessage || 'Simulated Network Error (Packet Loss)');
+            }
+        }
+        return next(req);
+    };
+}

package/dist/browser/presets/android.d.ts

@@ -0,0 +1,2 @@
+import { ClientOptions } from '../types/index.js';
+export default function android(): ClientOptions;

package/dist/browser/presets/android.js

@@ -0,0 +1,16 @@
+import { USER_AGENTS } from '../constants/user-agents.js';
+export default function android() {
+    return {
+        headers: {
+            'User-Agent': USER_AGENTS.ANDROID,
+            'Accept': '*/*',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Sec-CH-UA': '"Google Chrome";v="87", "SamsungBrowser";v="14", "Not;A=Brand";v="99"',
+            'Sec-CH-UA-Mobile': '?1',
+            'Sec-CH-UA-Platform': '"Android"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'cross-site'
+        }
+    };
+}

package/dist/browser/presets/anthropic.d.ts

@@ -0,0 +1,8 @@
+import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
+export interface AnthropicPresetOptions {
+    apiKey: string;
+    version?: string;
+    model?: string;
+}
+export declare function anthropic(options: AnthropicPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/browser/presets/anthropic.js

@@ -0,0 +1,27 @@
+export function anthropic(options) {
+    const _aiConfig = {
+        provider: 'anthropic',
+        apiKey: options.apiKey,
+        model: options.model ?? 'claude-sonnet-4-5',
+        headers: {
+            'anthropic-version': options.version || '2023-06-01',
+        },
+        memory: { maxPairs: 12 },
+    };
+    return {
+        baseUrl: 'https://api.anthropic.com/v1',
+        headers: {
+            'x-api-key': options.apiKey,
+            'anthropic-version': options.version || '2023-06-01',
+            'content-type': 'application/json'
+        },
+        timeout: 10 * 60 * 1000,
+        retry: {
+            maxAttempts: 5,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        _aiConfig,
+    };
+}

package/dist/browser/presets/aws.d.ts

@@ -0,0 +1,19 @@
+import { ClientOptions } from '../types/index.js';
+export interface AWSPresetOptions {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+    service: AWSService | string;
+    sessionToken?: string;
+    endpoint?: string;
+}
+export type AWSService = 's3' | 'dynamodb' | 'lambda' | 'sqs' | 'sns' | 'ses' | 'secretsmanager' | 'ssm' | 'sts' | 'iam' | 'ec2' | 'ecs' | 'eks' | 'cloudwatch' | 'logs' | 'events' | 'kinesis' | 'firehose' | 'apigateway' | 'execute-api' | 'cognito-idp' | 'cognito-identity' | 'kms' | 'athena' | 'glue' | 'stepfunctions' | 'states' | 'bedrock' | 'bedrock-runtime';
+export declare function aws(options: AWSPresetOptions): ClientOptions;
+export declare function awsS3(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsDynamoDB(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsLambda(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsSQS(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsSNS(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsSES(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsSecretsManager(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function awsBedrock(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;