stealth-fetch-plus 0.1.1

package/dist/compat/web.d.ts

@@ -0,0 +1,15 @@
+import { HttpResponse } from '../client.js';
+
+interface WebResponsePair {
+    response: Response;
+    clone: Response;
+}
+/**
+ * Convert a stealth-fetch HttpResponse into a standard Web Response.
+ * Note: Do not call HttpResponse.text/json/arrayBuffer before converting.
+ */
+declare function toWebResponse(response: HttpResponse, options?: {
+    tee?: boolean;
+}): Response | WebResponsePair;
+
+export { type WebResponsePair, toWebResponse };

package/dist/compat/web.js

@@ -0,0 +1,31 @@
+function toWebResponse(response, options) {
+  if (response.body.locked) {
+    throw new Error("Cannot convert to Web Response: body stream is already locked/consumed");
+  }
+  const headers = new Headers();
+  if (response.rawHeaders && response.rawHeaders.length > 0) {
+    for (const [name, value] of response.rawHeaders) {
+      headers.append(name, value);
+    }
+  } else {
+    for (const [name, value] of Object.entries(response.headers)) {
+      headers.set(name, value);
+    }
+  }
+  const init = {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  };
+  if (options?.tee) {
+    const [a, b] = response.body.tee();
+    return {
+      response: new Response(a, init),
+      clone: new Response(b, init)
+    };
+  }
+  return new Response(response.body, init);
+}
+export {
+  toWebResponse
+};

package/dist/connection-pool.d.ts

@@ -0,0 +1,39 @@
+import { Http2Client } from './http2/client.js';
+import './utils/url.js';
+import './http2/connection.js';
+import 'node:buffer';
+import 'node:events';
+import 'node:stream';
+import './http2/stream.js';
+import './http2/constants.js';
+import './http2/flow-control.js';
+
+/**
+ * V8 isolate-level HTTP/2 connection pool.
+ * Reuses H2 connections to the same origin, leveraging HTTP/2 stream
+ * multiplexing to avoid redundant TCP + TLS + SETTINGS handshakes.
+ *
+ * Pool lives in the global scope of the V8 isolate.
+ * CF Workers may reuse isolates across requests, so pooled connections
+ * persist for the isolate's lifetime (subject to idle timeout).
+ */
+
+/**
+ * Get a pooled H2 client for the given origin.
+ * Returns null if no usable connection exists.
+ */
+declare function getPooledClient(hostname: string, port: number, connectHostname?: string): Http2Client | null;
+/**
+ * Add an H2 client to the pool for reuse.
+ */
+declare function poolClient(hostname: string, port: number, client: Http2Client, connectHostname?: string): void;
+/**
+ * Remove a client from the pool (e.g. on GOAWAY or error).
+ */
+declare function removePooled(hostname: string, port: number, connectHostname?: string): void;
+/**
+ * Clear all pooled connections. Useful for testing.
+ */
+declare function clearPool(): void;
+
+export { clearPool, getPooledClient, poolClient, removePooled };

package/dist/connection-pool.js

@@ -0,0 +1,84 @@
+const POOL_TTL = 6e4;
+const MAX_POOL_SIZE = 20;
+const pool = /* @__PURE__ */ new Map();
+const goawayRegistered = /* @__PURE__ */ new WeakSet();
+function makeKey(hostname, port, connectHostname) {
+  return connectHostname ? `${hostname}:${port}@${connectHostname}` : `${hostname}:${port}`;
+}
+function getPooledClient(hostname, port, connectHostname) {
+  const key = makeKey(hostname, port, connectHostname);
+  const entry = pool.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.lastUsedAt > POOL_TTL) {
+    pool.delete(key);
+    entry.client.close().catch(() => {
+    });
+    return null;
+  }
+  if (!entry.client.hasCapacity) {
+    pool.delete(key);
+    entry.client.close().catch(() => {
+    });
+    return null;
+  }
+  entry.lastUsedAt = Date.now();
+  return entry.client;
+}
+function poolClient(hostname, port, client, connectHostname) {
+  const key = makeKey(hostname, port, connectHostname);
+  if (pool.size >= MAX_POOL_SIZE && !pool.has(key)) {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [k, v] of pool) {
+      if (v.lastUsedAt < oldestTime) {
+        oldestTime = v.lastUsedAt;
+        oldestKey = k;
+      }
+    }
+    if (oldestKey) {
+      const evicted = pool.get(oldestKey);
+      pool.delete(oldestKey);
+      evicted?.client.close().catch(() => {
+      });
+    }
+  }
+  const existing = pool.get(key);
+  if (existing && existing.client !== client) {
+    existing.client.close().catch(() => {
+    });
+  }
+  if (!goawayRegistered.has(client)) {
+    goawayRegistered.add(client);
+    client.onGoaway(() => {
+      const entry = pool.get(key);
+      if (entry?.client === client) {
+        pool.delete(key);
+        client.close().catch(() => {
+        });
+      }
+    });
+  }
+  pool.set(key, { client, lastUsedAt: Date.now() });
+}
+function removePooled(hostname, port, connectHostname) {
+  const key = makeKey(hostname, port, connectHostname);
+  const entry = pool.get(key);
+  if (entry) {
+    pool.delete(key);
+    entry.client.close().catch(() => {
+    });
+  }
+}
+function clearPool() {
+  for (const entry of pool.values()) {
+    entry.client.close().catch(() => {
+    });
+  }
+  pool.clear();
+}
+export {
+  clearPool,
+  getPooledClient,
+  poolClient,
+  removePooled
+};

package/dist/dns-cache.d.ts

@@ -0,0 +1,25 @@
+import { CfCheckResult } from './socket/nat64.js';
+
+/**
+ * V8 isolate-level DNS cache for CF CDN detection results.
+ * Caches resolveAndCheckCloudflare() results (IPv4/IPv6 + isCf flag)
+ * to avoid repeated DoH queries for the same hostname.
+ *
+ * Uses the same LRU pattern as protocol-cache.ts (Map delete+re-insert).
+ * TTL is derived from DNS response TTL values (clamped to 30s–5min).
+ */
+
+/**
+ * Look up cached DNS result. Returns null on miss or expiry.
+ * On hit, refreshes LRU position (Map delete+re-insert).
+ */
+declare function getCachedDns(hostname: string): CfCheckResult | null;
+/**
+ * Store DNS result in cache with clamped TTL.
+ * Evicts oldest entry if at capacity.
+ */
+declare function setCachedDns(hostname: string, result: CfCheckResult): void;
+/** Clear all cached DNS entries. Exported for testing and user API. */
+declare function clearDnsCache(): void;
+
+export { clearDnsCache, getCachedDns, setCachedDns };

package/dist/dns-cache.js

@@ -0,0 +1,44 @@
+const MIN_TTL = 3e4;
+const MAX_TTL = 5 * 6e4;
+const MAX_ENTRIES = 500;
+const cache = /* @__PURE__ */ new Map();
+function getCachedDns(hostname) {
+  const entry = cache.get(hostname);
+  if (!entry) return null;
+  if (Date.now() > entry.expiresAt) {
+    cache.delete(hostname);
+    return null;
+  }
+  cache.delete(hostname);
+  cache.set(hostname, entry);
+  return {
+    isCf: entry.isCf,
+    ipv4: entry.ipv4,
+    ipv6: entry.ipv6,
+    dnsMs: 0,
+    // cached — no actual DNS query
+    ttl: Math.max(0, Math.round((entry.expiresAt - Date.now()) / 1e3))
+  };
+}
+function setCachedDns(hostname, result) {
+  const ttlMs = result.ttl > 0 ? Math.max(MIN_TTL, Math.min(result.ttl * 1e3, MAX_TTL)) : 1e4;
+  if (cache.size >= MAX_ENTRIES && !cache.has(hostname)) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey) cache.delete(firstKey);
+  }
+  cache.set(hostname, {
+    ipv4: result.ipv4,
+    ipv6: result.ipv6,
+    isCf: result.isCf,
+    expiresAt: Date.now() + ttlMs,
+    dnsMs: result.dnsMs
+  });
+}
+function clearDnsCache() {
+  cache.clear();
+}
+export {
+  clearDnsCache,
+  getCachedDns,
+  setCachedDns
+};

package/dist/http1/chunked.d.ts

@@ -0,0 +1,35 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * HTTP/1.1 chunked transfer encoding decoder.
+ * Decodes chunked body data into raw content.
+ *
+ * Chunked format:
+ *   <hex-size>\r\n
+ *   <data>\r\n
+ *   ...
+ *   0\r\n
+ *   \r\n
+ */
+
+/**
+ * Stateful chunked transfer encoding decoder.
+ * Feed raw data via feed(), collect decoded chunks via getChunks().
+ */
+declare class ChunkedDecoder {
+    private state;
+    private buffer;
+    private currentChunkSize;
+    private chunks;
+    private _done;
+    /** Whether all chunks have been received (final 0-length chunk) */
+    get done(): boolean;
+    /** Feed raw data into the decoder */
+    feed(data: Buffer | Uint8Array): void;
+    /** Get and clear decoded chunks */
+    getChunks(): Buffer[];
+    private process;
+    private findCRLF;
+}
+
+export { ChunkedDecoder };

package/dist/http1/chunked.js

@@ -0,0 +1,87 @@
+import { Buffer } from "node:buffer";
+var ChunkedState = /* @__PURE__ */ ((ChunkedState2) => {
+  ChunkedState2[ChunkedState2["READ_SIZE"] = 0] = "READ_SIZE";
+  ChunkedState2[ChunkedState2["READ_DATA"] = 1] = "READ_DATA";
+  ChunkedState2[ChunkedState2["READ_DATA_CRLF"] = 2] = "READ_DATA_CRLF";
+  ChunkedState2[ChunkedState2["DONE"] = 3] = "DONE";
+  return ChunkedState2;
+})(ChunkedState || {});
+class ChunkedDecoder {
+  state = 0 /* READ_SIZE */;
+  buffer = Buffer.alloc(0);
+  currentChunkSize = 0;
+  chunks = [];
+  _done = false;
+  /** Whether all chunks have been received (final 0-length chunk) */
+  get done() {
+    return this._done;
+  }
+  /** Feed raw data into the decoder */
+  feed(data) {
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    this.buffer = this.buffer.length > 0 ? Buffer.concat([this.buffer, buf]) : buf;
+    this.process();
+  }
+  /** Get and clear decoded chunks */
+  getChunks() {
+    const result = this.chunks;
+    this.chunks = [];
+    return result;
+  }
+  process() {
+    while (this.buffer.length > 0 && !this._done) {
+      switch (this.state) {
+        case 0 /* READ_SIZE */: {
+          const crlfIdx = this.findCRLF();
+          if (crlfIdx === -1) return;
+          const sizeLine = this.buffer.subarray(0, crlfIdx).toString("ascii");
+          const semiIdx = sizeLine.indexOf(";");
+          const sizeStr = semiIdx === -1 ? sizeLine : sizeLine.substring(0, semiIdx);
+          this.currentChunkSize = parseInt(sizeStr.trim(), 16);
+          if (isNaN(this.currentChunkSize) || this.currentChunkSize < 0) {
+            throw new Error(`Invalid chunk size: "${sizeStr.trim()}"`);
+          }
+          if (this.currentChunkSize > 16 * 1024 * 1024) {
+            throw new Error(`Chunk size too large: ${this.currentChunkSize}`);
+          }
+          this.buffer = this.buffer.subarray(crlfIdx + 2);
+          if (this.currentChunkSize === 0) {
+            this._done = true;
+            return;
+          }
+          this.state = 1 /* READ_DATA */;
+          break;
+        }
+        case 1 /* READ_DATA */: {
+          if (this.buffer.length < this.currentChunkSize) return;
+          this.chunks.push(this.buffer.subarray(0, this.currentChunkSize));
+          this.buffer = this.buffer.subarray(this.currentChunkSize);
+          this.state = 2 /* READ_DATA_CRLF */;
+          break;
+        }
+        case 2 /* READ_DATA_CRLF */: {
+          if (this.buffer.length < 2) return;
+          if (this.buffer[0] !== 13 || this.buffer[1] !== 10) {
+            throw new Error("Expected CRLF after chunk data");
+          }
+          this.buffer = this.buffer.subarray(2);
+          this.state = 0 /* READ_SIZE */;
+          break;
+        }
+        case 3 /* DONE */:
+          return;
+      }
+    }
+  }
+  findCRLF() {
+    for (let i = 0; i < this.buffer.length - 1; i++) {
+      if (this.buffer[i] === 13 && this.buffer[i + 1] === 10) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}
+export {
+  ChunkedDecoder
+};

package/dist/http1/client.d.ts

@@ -0,0 +1,28 @@
+import { Duplex } from 'node:stream';
+
+interface Http1Request {
+    method: string;
+    path: string;
+    hostname: string;
+    headers: Record<string, string>;
+    body?: Uint8Array | ReadableStream<Uint8Array> | null;
+    signal?: AbortSignal;
+    /** Timeout waiting for response headers (ms) */
+    headersTimeout?: number;
+    /** Timeout waiting for response body data (ms) */
+    bodyTimeout?: number;
+}
+interface Http1Response {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    rawHeaders: Array<[string, string]>;
+    protocol: "http/1.1";
+    body: ReadableStream<Uint8Array>;
+}
+/**
+ * Send an HTTP/1.1 request over a raw socket and return the response.
+ */
+declare function http1Request(socket: Duplex, request: Http1Request): Promise<Http1Response>;
+
+export { type Http1Request, type Http1Response, http1Request };

package/dist/http1/client.js

@@ -0,0 +1,289 @@
+import { Buffer } from "node:buffer";
+import { serializeHttp1Headers } from "../utils/headers.js";
+import { parseResponseHead } from "./parser.js";
+import { ChunkedDecoder } from "./chunked.js";
+async function http1Request(socket, request) {
+  if (request.signal?.aborted) {
+    throw request.signal.reason ?? new DOMException("Aborted", "AbortError");
+  }
+  const reqHeaders = { ...request.headers };
+  if (!reqHeaders["host"]) {
+    reqHeaders["host"] = request.hostname;
+  }
+  if (!reqHeaders["connection"]) {
+    reqHeaders["connection"] = "close";
+  }
+  if (!reqHeaders["user-agent"]) {
+    reqHeaders["user-agent"] = "stealth-fetch/0.1";
+  }
+  if (reqHeaders["transfer-encoding"] && reqHeaders["content-length"]) {
+    delete reqHeaders["content-length"];
+  }
+  const isStreamBody = request.body instanceof ReadableStream;
+  if (isStreamBody) {
+    if (!reqHeaders["transfer-encoding"]) {
+      reqHeaders["transfer-encoding"] = "chunked";
+    }
+    delete reqHeaders["content-length"];
+  } else if (request.body && !reqHeaders["content-length"]) {
+    reqHeaders["content-length"] = String(request.body.byteLength);
+  }
+  const requestLine = `${request.method.toUpperCase()} ${request.path} HTTP/1.1\r
+`;
+  const headersStr = serializeHttp1Headers(reqHeaders);
+  const head = `${requestLine + headersStr}\r
+`;
+  await writeToSocket(socket, Buffer.from(head, "utf-8"));
+  if (isStreamBody && request.body instanceof ReadableStream) {
+    const reader = request.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = Buffer.from(value);
+        await writeToSocket(socket, Buffer.from(`${chunk.byteLength.toString(16)}\r
+`));
+        await writeToSocket(socket, chunk);
+        await writeToSocket(socket, Buffer.from("\r\n"));
+      }
+      await writeToSocket(socket, Buffer.from("0\r\n\r\n"));
+    } catch (err) {
+      reader.cancel(err).catch(() => {
+      });
+      throw err;
+    } finally {
+      reader.releaseLock();
+    }
+  } else if (request.body && !isStreamBody && request.body.byteLength > 0) {
+    await writeToSocket(socket, Buffer.from(request.body));
+  }
+  return readResponse(socket, request.signal, request.headersTimeout, request.bodyTimeout);
+}
+function writeToSocket(socket, data) {
+  return new Promise((resolve, reject) => {
+    socket.write(data, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+function readResponse(socket, signal, headersTimeout, bodyTimeout) {
+  return new Promise((resolve, reject) => {
+    let headBuffer = Buffer.alloc(0);
+    let headParsed = false;
+    let parsed = null;
+    let bodyBytesReceived = 0;
+    let chunkedDecoder = null;
+    const hasHeadersTimeout = typeof headersTimeout === "number" && headersTimeout > 0 && headersTimeout < Infinity;
+    const hasBodyTimeout = typeof bodyTimeout === "number" && bodyTimeout > 0 && bodyTimeout < Infinity;
+    let bodyController = null;
+    let bodyStreamClosed = false;
+    let headersTimer = null;
+    let bodyTimer = null;
+    let lastBodyActivity = 0;
+    const bodyStream = new ReadableStream({
+      start(controller) {
+        bodyController = controller;
+      },
+      cancel() {
+        bodyStreamClosed = true;
+        cleanup();
+      }
+    });
+    const closeBody = () => {
+      if (bodyController && !bodyStreamClosed) {
+        bodyStreamClosed = true;
+        try {
+          bodyController.close();
+        } catch {
+        }
+      }
+      clearBodyTimer();
+    };
+    const enqueueBody = (data) => {
+      if (bodyController && !bodyStreamClosed) {
+        try {
+          bodyController.enqueue(data);
+        } catch {
+        }
+      }
+    };
+    const cleanup = () => {
+      socket.removeListener("data", onData);
+      socket.removeListener("end", onEnd);
+      socket.removeListener("error", onError);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      clearHeadersTimer();
+      clearBodyTimer();
+    };
+    const onAbort = () => {
+      const err = signal?.reason ?? new DOMException("Aborted", "AbortError");
+      if (!headParsed) {
+        reject(err);
+      } else if (bodyController && !bodyStreamClosed) {
+        bodyStreamClosed = true;
+        try {
+          bodyController.error(err);
+        } catch {
+        }
+      }
+      cleanup();
+      socket.destroy();
+    };
+    const clearHeadersTimer = () => {
+      if (headersTimer) {
+        clearTimeout(headersTimer);
+        headersTimer = null;
+      }
+    };
+    const clearBodyTimer = () => {
+      if (bodyTimer) {
+        clearTimeout(bodyTimer);
+        bodyTimer = null;
+      }
+    };
+    const onHeadersTimeout = () => {
+      if (headParsed) return;
+      const err = new DOMException(`Headers timeout after ${headersTimeout}ms`, "TimeoutError");
+      reject(err);
+      cleanup();
+      socket.destroy();
+    };
+    const onBodyTimeoutCheck = () => {
+      bodyTimer = null;
+      if (!hasBodyTimeout) return;
+      const elapsed = Date.now() - lastBodyActivity;
+      if (elapsed >= bodyTimeout) {
+        const err = new DOMException(`Body timeout after ${bodyTimeout}ms`, "TimeoutError");
+        if (bodyController && !bodyStreamClosed) {
+          bodyStreamClosed = true;
+          try {
+            bodyController.error(err);
+          } catch {
+          }
+        }
+        cleanup();
+        socket.destroy();
+        return;
+      }
+      bodyTimer = setTimeout(onBodyTimeoutCheck, bodyTimeout - elapsed);
+    };
+    const markBodyActivity = () => {
+      if (!hasBodyTimeout) return;
+      lastBodyActivity = Date.now();
+      if (!bodyTimer) {
+        bodyTimer = setTimeout(onBodyTimeoutCheck, bodyTimeout);
+      }
+    };
+    const onData = (chunk) => {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (!headParsed) {
+        headBuffer = headBuffer.length > 0 ? Buffer.concat([headBuffer, buf]) : buf;
+        if (headBuffer.length > 81920) {
+          reject(new Error("Response headers too large (>80KB)"));
+          cleanup();
+          return;
+        }
+        const result = parseResponseHead(headBuffer);
+        if (!result) return;
+        if (result.response.status === 100) {
+          headBuffer = headBuffer.subarray(result.bodyStart);
+          return;
+        }
+        headParsed = true;
+        parsed = result.response;
+        clearHeadersTimer();
+        resolve({
+          status: parsed.status,
+          statusText: parsed.statusText,
+          headers: parsed.headers,
+          rawHeaders: parsed.rawHeaders,
+          protocol: "http/1.1",
+          body: bodyStream
+        });
+        const bodyData = headBuffer.subarray(result.bodyStart);
+        headBuffer = Buffer.alloc(0);
+        if (parsed.bodyMode === "chunked") {
+          chunkedDecoder = new ChunkedDecoder();
+        }
+        if (hasBodyTimeout && !(parsed.bodyMode === "content-length" && parsed.contentLength === 0)) {
+          markBodyActivity();
+        }
+        if (bodyData.length > 0) {
+          processBodyData(bodyData);
+        }
+        if (parsed.bodyMode === "content-length" && parsed.contentLength === 0) {
+          closeBody();
+          cleanup();
+        }
+      } else {
+        processBodyData(buf);
+      }
+    };
+    const processBodyData = (data) => {
+      if (!parsed) return;
+      if (hasBodyTimeout) {
+        markBodyActivity();
+      }
+      if (parsed.bodyMode === "chunked" && chunkedDecoder) {
+        chunkedDecoder.feed(data);
+        for (const chunk of chunkedDecoder.getChunks()) {
+          enqueueBody(chunk);
+        }
+        if (chunkedDecoder.done) {
+          closeBody();
+          cleanup();
+        }
+      } else if (parsed.bodyMode === "content-length") {
+        const remaining = parsed.contentLength - bodyBytesReceived;
+        const toEnqueue = data.length <= remaining ? data : data.subarray(0, remaining);
+        bodyBytesReceived += toEnqueue.length;
+        enqueueBody(toEnqueue);
+        if (bodyBytesReceived >= parsed.contentLength) {
+          closeBody();
+          cleanup();
+        }
+      } else {
+        enqueueBody(data);
+      }
+    };
+    const onEnd = () => {
+      if (!headParsed) {
+        reject(new Error("Connection closed before response headers received"));
+      } else {
+        closeBody();
+      }
+      cleanup();
+    };
+    const onError = (err) => {
+      if (!headParsed) {
+        reject(err);
+      } else {
+        if (bodyController && !bodyStreamClosed) {
+          bodyStreamClosed = true;
+          try {
+            bodyController.error(err);
+          } catch {
+          }
+        }
+      }
+      cleanup();
+    };
+    socket.on("data", onData);
+    socket.on("end", onEnd);
+    socket.on("error", onError);
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (hasHeadersTimeout) {
+      headersTimer = setTimeout(onHeadersTimeout, headersTimeout);
+    }
+  });
+}
+export {
+  http1Request
+};