recker 1.0.26 → 1.0.27

package/dist/browser/websocket/client.js

@@ -0,0 +1,313 @@
+import { WebSocket } from 'undici';
+import { EventEmitter } from 'events';
+import { pipeline } from 'node:stream/promises';
+import { webToNodeStream } from '../utils/streaming.js';
+import { StateError, StreamError, ConnectionError } from '../core/errors.js';
+export class ReckerWebSocket extends EventEmitter {
+    ws = null;
+    url;
+    options;
+    reconnectAttempts = 0;
+    reconnectTimer;
+    heartbeatTimer;
+    isClosed = false;
+    isReconnecting = false;
+    pongWatchdog;
+    backoff;
+    closedByUser = false;
+    constructor(url, options = {}) {
+        super();
+        this.url = url;
+        this.options = {
+            protocols: options.protocols || [],
+            headers: options.headers || {},
+            reconnect: options.reconnect ?? false,
+            reconnectDelay: options.reconnectDelay ?? 1000,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? 5,
+            heartbeatInterval: options.heartbeatInterval ?? 30000,
+            heartbeatTimeout: options.heartbeatTimeout ?? 10000,
+            dispatcher: options.dispatcher,
+            proxy: options.proxy,
+            tls: options.tls,
+            perMessageDeflate: options.perMessageDeflate ?? false
+        };
+        this.backoff = {
+            base: this.options.reconnectDelay,
+            factor: 2,
+            jitter: true,
+            max: 30000
+        };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                const wsOptions = {
+                    headers: this.options.headers,
+                    dispatcher: this.options.dispatcher,
+                    perMessageDeflate: this.options.perMessageDeflate,
+                };
+                if (this.options.proxy) {
+                    const proxyConfig = typeof this.options.proxy === 'string'
+                        ? { url: this.options.proxy }
+                        : this.options.proxy;
+                    const { ProxyAgent } = require('undici');
+                    wsOptions.dispatcher = new ProxyAgent(proxyConfig.url);
+                }
+                if (this.options.tls) {
+                    wsOptions.tls = this.options.tls;
+                }
+                this.ws = new WebSocket(this.url, this.options.protocols, wsOptions);
+                this.ws.addEventListener('open', () => {
+                    this.reconnectAttempts = 0;
+                    this.isReconnecting = false;
+                    this.startHeartbeat();
+                    this.emit('open');
+                    resolve();
+                });
+                this.ws.addEventListener('message', (event) => {
+                    const message = {
+                        data: event.data,
+                        isBinary: event.data instanceof Buffer
+                    };
+                    this.emit('message', message);
+                    this.stopPongWatchdog();
+                });
+                this.ws.addEventListener('close', (event) => {
+                    this.stopHeartbeat();
+                    this.stopPongWatchdog();
+                    this.emit('close', event.code, event.reason);
+                    if (!this.closedByUser && !this.isClosed && this.options.reconnect) {
+                        this.attemptReconnect();
+                    }
+                });
+                this.ws.addEventListener('error', (event) => {
+                    const err = event.error instanceof Error
+                        ? event.error
+                        : new ConnectionError('WebSocket connection error', {
+                            host: this.url,
+                            retriable: true,
+                        });
+                    this.emit('error', err);
+                    reject(err);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async send(data, options) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new StateError('WebSocket is not connected', {
+                expectedState: 'open',
+                actualState: this.ws ? 'closed' : 'not-created',
+            });
+        }
+        const awaitDrain = options?.awaitDrain ?? false;
+        const highWaterMark = options?.highWaterMark ?? 16 * 1024;
+        this.ws.send(data);
+        if (awaitDrain) {
+            await this.waitForDrain(highWaterMark);
+        }
+    }
+    async sendStream(stream, options) {
+        for await (const chunk of stream) {
+            await this.send(chunk, options);
+        }
+    }
+    sendJSON(data) {
+        void this.send(JSON.stringify(data));
+    }
+    close(code = 1000, reason = '') {
+        this.isClosed = true;
+        this.closedByUser = true;
+        this.stopHeartbeat();
+        this.clearReconnectTimer();
+        if (this.ws) {
+            this.ws.close(code, reason);
+            this.ws = null;
+        }
+    }
+    ping() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const anyWs = this.ws;
+        if (typeof anyWs.ping === 'function') {
+            try {
+                anyWs.ping();
+                return;
+            }
+            catch {
+            }
+        }
+        try {
+            this.ws.send('__heartbeat__');
+        }
+        catch {
+        }
+    }
+    get readyState() {
+        return this.ws?.readyState ?? WebSocket.CLOSED;
+    }
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    toReadable() {
+        if (!this.ws)
+            return null;
+        const wsAny = this.ws;
+        if (wsAny.readable) {
+            return webToNodeStream(wsAny.readable);
+        }
+        return null;
+    }
+    async pipeFrom(source, options) {
+        await this.sendStream(source, options);
+    }
+    async pipeTo(destination) {
+        const readable = this.toReadable();
+        if (!readable) {
+            throw new StreamError('WebSocket has no readable stream', {
+                streamType: 'websocket',
+                retriable: false,
+            });
+        }
+        await pipeline(readable, destination);
+    }
+    async *[Symbol.asyncIterator]() {
+        const queue = [];
+        let resolveNext = null;
+        let closed = false;
+        const messageHandler = (msg) => {
+            if (resolveNext) {
+                resolveNext(msg);
+                resolveNext = null;
+            }
+            else {
+                queue.push(msg);
+            }
+        };
+        const closeHandler = () => {
+            closed = true;
+            if (resolveNext) {
+                resolveNext(null);
+                resolveNext = null;
+            }
+        };
+        this.on('message', messageHandler);
+        this.on('close', closeHandler);
+        try {
+            while (true) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                }
+                else {
+                    if (closed)
+                        break;
+                    const msg = await new Promise((resolve) => {
+                        resolveNext = resolve;
+                    });
+                    if (msg) {
+                        yield msg;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.off('message', messageHandler);
+            this.off('close', closeHandler);
+        }
+    }
+    attemptReconnect() {
+        if (this.isReconnecting)
+            return;
+        if (this.options.maxReconnectAttempts > 0 &&
+            this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+            this.emit('max-reconnect-attempts');
+            return;
+        }
+        this.isReconnecting = true;
+        this.reconnectAttempts++;
+        const baseDelay = this.backoff.base * Math.pow(this.backoff.factor, this.reconnectAttempts - 1);
+        const capped = this.backoff.max ? Math.min(baseDelay, this.backoff.max) : baseDelay;
+        const jittered = this.backoff.jitter ? randomJitter(capped) : capped;
+        this.emit('reconnecting', this.reconnectAttempts, jittered);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch((error) => {
+                this.emit('reconnect-error', error);
+            });
+        }, jittered);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+    startHeartbeat() {
+        if (this.options.heartbeatInterval <= 0)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.isConnected) {
+                this.ping();
+                this.startPongWatchdog();
+            }
+        }, this.options.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        this.stopPongWatchdog();
+    }
+    startPongWatchdog() {
+        this.stopPongWatchdog();
+        if (this.options.heartbeatTimeout <= 0)
+            return;
+        this.pongWatchdog = setTimeout(() => {
+            this.emit('heartbeat-timeout');
+            if (!this.closedByUser && this.options.reconnect) {
+                this.ws?.close(4000, 'heartbeat timeout');
+            }
+        }, this.options.heartbeatTimeout);
+    }
+    stopPongWatchdog() {
+        if (this.pongWatchdog) {
+            clearTimeout(this.pongWatchdog);
+            this.pongWatchdog = undefined;
+        }
+    }
+    getBufferedAmount() {
+        return this.ws?.bufferedAmount ?? 0;
+    }
+    async waitForDrain(highWaterMark) {
+        const buffered = this.getBufferedAmount();
+        if (buffered <= highWaterMark)
+            return;
+        await new Promise((resolve) => {
+            const check = () => {
+                if (this.getBufferedAmount() <= highWaterMark || !this.isConnected) {
+                    resolve();
+                }
+                else {
+                    setTimeout(check, 10);
+                }
+            };
+            setTimeout(check, 10);
+        });
+    }
+}
+export function createWebSocket(url, options) {
+    const ws = new ReckerWebSocket(url, options);
+    ws.connect().catch(() => {
+    });
+    return ws;
+}
+function randomJitter(value) {
+    const jitter = 0.2 * value;
+    return value - jitter + Math.random() * (2 * jitter);
+}

package/dist/cli/index.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export {};

package/dist/cli/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { program } from 'commander';
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';

package/dist/transport/fetch.d.ts

@@ -1,5 +1,11 @@
 import { ReckerRequest, ReckerResponse, Transport } from '../types/index.js';
+export interface FetchTransportOptions {
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    keepalive?: boolean;
+}
 export declare class FetchTransport implements Transport {
-    constructor();
+    private options;
+    constructor(options?: FetchTransportOptions);
     dispatch(req: ReckerRequest): Promise<ReckerResponse>;
 }

package/dist/transport/fetch.js

@@ -1,12 +1,29 @@
 export class FetchTransport {
-    constructor() { }
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
     async dispatch(req) {
         const start = performance.now();
+        let timeoutId;
+        let abortController;
+        const timeoutMs = typeof req.timeout === 'number'
+            ? req.timeout
+            : req.timeout?.request;
+        let signal = req.signal;
+        if (timeoutMs && !signal) {
+            abortController = new AbortController();
+            signal = abortController.signal;
+            timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+        }
         const requestInit = {
             method: req.method,
             headers: req.headers,
             body: req.body,
-            signal: req.signal,
+            signal,
+            credentials: this.options.credentials,
+            cache: this.options.cache,
+            keepalive: this.options.keepalive ?? true,
             duplex: req.body ? 'half' : undefined
         };
         try {
@@ -16,84 +33,22 @@ export class FetchTransport {
                 total: totalTime,
                 firstByte: totalTime,
             };
-            const reckerResponse = {
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                ok: response.ok,
-                url: response.url,
-                timings,
-                raw: response,
-                json: () => response.json(),
-                text: () => response.text(),
-                blob: () => response.blob(),
-                cleanText: async () => {
-                    const text = await response.text();
-                    return text.replace(/<[^>]*>?/gm, '');
-                },
-                read: () => response.body,
-                clone: () => {
-                    const cloned = response.clone();
-                    return createReckerResponseWrapper(cloned, timings);
-                },
-                async *sse() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const lines = value.split('\n');
-                        for (const line of lines) {
-                            if (line.startsWith('data: ')) {
-                                yield { data: line.slice(6) };
-                            }
-                        }
-                    }
-                },
-                async *download() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.getReader();
-                    let loaded = 0;
-                    const total = Number(response.headers.get('content-length')) || undefined;
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        loaded += value.length;
-                        yield {
-                            loaded,
-                            transferred: loaded,
-                            total,
-                            percent: total ? (loaded / total) * 100 : undefined,
-                            direction: 'download'
-                        };
-                    }
-                },
-                async *[Symbol.asyncIterator]() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.getReader();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        yield value;
-                    }
-                }
-            };
-            return reckerResponse;
+            return new FetchResponseWrapper(response, timings);
         }
         catch (error) {
+            if (error.name === 'AbortError' && abortController) {
+                const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
+                timeoutError.name = 'TimeoutError';
+                throw timeoutError;
+            }
             throw error;
         }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
 }
-function createReckerResponseWrapper(response, timings) {
-    return new FetchResponseWrapper(response, timings);
-}
 class FetchResponseWrapper {
     raw;
     timings;
@@ -118,12 +73,39 @@ class FetchResponseWrapper {
             return;
         const stream = this.raw.body.pipeThrough(new TextDecoderStream());
         const reader = stream.getReader();
+        let buffer = '';
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            if (value.startsWith('data: ')) {
-                yield { data: value.slice(6) };
+            buffer += value;
+            const events = buffer.split('\n\n');
+            buffer = events.pop() || '';
+            for (const event of events) {
+                if (!event.trim())
+                    continue;
+                let data = '';
+                let eventType;
+                let id;
+                let retry;
+                const lines = event.split('\n');
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        data = data ? data + '\n' + line.slice(6) : line.slice(6);
+                    }
+                    else if (line.startsWith('event: ')) {
+                        eventType = line.slice(7);
+                    }
+                    else if (line.startsWith('id: ')) {
+                        id = line.slice(4);
+                    }
+                    else if (line.startsWith('retry: ')) {
+                        retry = parseInt(line.slice(7), 10);
+                    }
+                }
+                if (data) {
+                    yield { data, event: eventType, id, retry };
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -58,6 +58,24 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
+      "node": {
+        "import": "./dist/index.js",
+        "require": "./dist/index.cjs"
+      },
+      "browser": {
+        "import": "./dist/browser/browser/index.js",
+        "default": "./dist/browser/browser/index.js"
+      },
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/browser/index.d.ts",
+      "import": "./dist/browser/browser/index.js",
+      "default": "./dist/browser/browser/index.js"
+    },
+    "./node": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
@@ -114,8 +132,15 @@
       "types": "./dist/mini.d.ts",
       "import": "./dist/mini.js"
     },
+    "./presets/*": {
+      "types": "./dist/presets/*.d.ts",
+      "import": "./dist/presets/*.js"
+    },
     "./package.json": "./package.json"
   },
+  "browser": "./dist/browser/browser/index.js",
+  "unpkg": "./dist/browser/index.umd.min.js",
+  "jsdelivr": "./dist/browser/index.umd.min.js",
   "bin": {
     "rek": "./dist/cli/index.js",
     "recker": "./dist/cli/index.js"
@@ -164,8 +189,10 @@
     "commander": "^14.0.0",
     "cross-fetch": "^4.1.0",
     "domhandler": "^5.0.3",
+    "esbuild": "^0.24.2",
     "fastembed": "^2.0.0",
     "got": "^14.6.5",
+    "happy-dom": "^20.0.11",
     "husky": "^9.1.7",
     "ky": "^1.14.0",
     "make-fetch-happen": "^15.0.3",
@@ -186,11 +213,16 @@
     "zod": "^4.1.13"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "pnpm build:node && pnpm build:browser",
+    "build:node": "tsc",
+    "build:browser": "tsc -p tsconfig.browser.json",
+    "build:browser:bundle": "pnpm build:browser && node scripts/bundle-browser.js",
     "build:embeddings": "tsx scripts/build-embeddings.ts",
     "test": "NODE_OPTIONS='--max-old-space-size=512' vitest run",
     "test:coverage": "NODE_OPTIONS='--max-old-space-size=512' vitest run --coverage",
     "test:light": "NODE_OPTIONS='--max-old-space-size=256' vitest run --poolOptions.forks.maxForks=1",
+    "test:browser": "vitest run --config vitest.config.browser.ts",
+    "test:browser:coverage": "vitest run --config vitest.config.browser.ts --coverage",
     "bench": "tsx benchmark/index.ts",
     "bench:compare": "tsx benchmark/http-clients-comparison.ts",
     "bench:all": "tsx benchmark/run-all.ts",