stealth-fetch 0.1.2

package/dist/http1/parser.d.ts

@@ -0,0 +1,29 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * HTTP/1.1 response parser.
+ * State machine that parses raw bytes into structured response objects.
+ */
+
+interface ParsedResponse {
+    httpVersion: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    /** Raw headers preserving original order and multi-values */
+    rawHeaders: Array<[string, string]>;
+    /** How the body should be read */
+    bodyMode: "content-length" | "chunked" | "close";
+    /** Content-Length value (if bodyMode is "content-length") */
+    contentLength: number;
+}
+/**
+ * Parse HTTP/1.1 response status line and headers from raw data.
+ * Returns null if not enough data has been received yet.
+ */
+declare function parseResponseHead(data: Buffer): {
+    response: ParsedResponse;
+    bodyStart: number;
+} | null;
+
+export { type ParsedResponse, parseResponseHead };

package/dist/http1/parser.js

@@ -0,0 +1,78 @@
+import { Buffer } from "node:buffer";
+const DOUBLE_CRLF = Buffer.from("\r\n\r\n");
+function parseResponseHead(data) {
+  const headerEnd = bufferIndexOf(data, DOUBLE_CRLF);
+  if (headerEnd === -1) return null;
+  const headSection = data.subarray(0, headerEnd).toString("latin1");
+  const bodyStart = headerEnd + 4;
+  const lines = headSection.split("\r\n");
+  if (lines.length === 0) return null;
+  const statusLine = lines[0];
+  const firstSpace = statusLine.indexOf(" ");
+  if (firstSpace === -1) return null;
+  const httpVersion = statusLine.substring(0, firstSpace);
+  const rest = statusLine.substring(firstSpace + 1);
+  const secondSpace = rest.indexOf(" ");
+  const status = secondSpace === -1 ? parseInt(rest, 10) : parseInt(rest.substring(0, secondSpace), 10);
+  if (isNaN(status) || status < 100 || status > 999) return null;
+  const statusText = secondSpace === -1 ? "" : rest.substring(secondSpace + 1);
+  const headers = {};
+  const rawHeaders = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.substring(0, colonIdx).trim().toLowerCase();
+    const value = line.substring(colonIdx + 1).trim();
+    rawHeaders.push([key, value]);
+    if (headers[key]) {
+      headers[key] += key === "set-cookie" ? `
+${value}` : `, ${value}`;
+    } else {
+      headers[key] = value;
+    }
+  }
+  let bodyMode = "close";
+  let contentLength = 0;
+  if (headers["transfer-encoding"]) {
+    if (headers["transfer-encoding"].includes("chunked")) {
+      bodyMode = "chunked";
+    }
+  } else if (headers["content-length"]) {
+    const cl = parseInt(headers["content-length"], 10);
+    if (!isNaN(cl) && cl >= 0) {
+      bodyMode = "content-length";
+      contentLength = cl;
+    }
+  }
+  return {
+    response: {
+      httpVersion,
+      status,
+      statusText,
+      headers,
+      rawHeaders,
+      bodyMode,
+      contentLength
+    },
+    bodyStart
+  };
+}
+function bufferIndexOf(haystack, needle) {
+  const len = needle.length;
+  const limit = haystack.length - len;
+  for (let i = 0; i <= limit; i++) {
+    let found = true;
+    for (let j = 0; j < len; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found) return i;
+  }
+  return -1;
+}
+export {
+  parseResponseHead
+};

package/dist/http2/client.d.ts

@@ -0,0 +1,64 @@
+import { ParsedUrl } from '../utils/url.js';
+import { Http2Connection, ConnectionOptions } from './connection.js';
+import 'node:buffer';
+import 'node:events';
+import 'node:stream';
+import './stream.js';
+import './constants.js';
+import './flow-control.js';
+
+interface Http2RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: Uint8Array | ReadableStream<Uint8Array> | null;
+    /** Timeout waiting for response headers (ms) */
+    headersTimeout?: number;
+    /** Timeout waiting for response body data (idle, ms) */
+    bodyTimeout?: number;
+}
+interface Http2Response {
+    status: number;
+    headers: Record<string, string>;
+    rawHeaders: Array<[string, string]>;
+    protocol: "h2";
+    body: ReadableStream<Uint8Array>;
+}
+/**
+ * HTTP/2 client. Manages a single connection and allows multiple requests
+ * (via stream multiplexing).
+ */
+declare class Http2Client {
+    private connection;
+    private constructor();
+    /**
+     * Create an Http2Client from an already-initialized Http2Connection.
+     * Used by auto-negotiation when the TLS socket is already established.
+     */
+    static fromConnection(connection: Http2Connection): Http2Client;
+    /**
+     * Connect to a server and perform HTTP/2 handshake via WASM TLS (with ALPN).
+     * Uses non-blocking SETTINGS: preface is sent immediately, handshake
+     * completes in parallel with the first request's header encoding.
+     */
+    static connect(hostname: string, port?: number, tls?: boolean, options?: ConnectionOptions, connectHostname?: string, signal?: AbortSignal): Promise<Http2Client>;
+    /**
+     * Send an HTTP/2 request and return the response.
+     */
+    request(url: string | ParsedUrl, options?: Http2RequestOptions): Promise<Http2Response>;
+    /** Whether the connection is still usable */
+    get isReady(): boolean;
+    /** Number of currently active streams */
+    get activeStreamCount(): number;
+    /** Remote peer's MAX_CONCURRENT_STREAMS */
+    get maxConcurrentStreams(): number;
+    /** Whether the connection can accept another stream */
+    get hasCapacity(): boolean;
+    /** Register a callback for GOAWAY events */
+    onGoaway(callback: () => void): void;
+    /** Remove a GOAWAY callback */
+    offGoaway(callback: () => void): void;
+    /** Close the connection */
+    close(): Promise<void>;
+}
+
+export { Http2Client, type Http2RequestOptions, type Http2Response };

package/dist/http2/client.js

@@ -0,0 +1,97 @@
+import { Buffer } from "node:buffer";
+import { createWasmTLSSocket, createPlainSocket } from "../socket/tls.js";
+import { parseUrl } from "../utils/url.js";
+import { buildPseudoHeaders, mergeHeaders } from "../utils/headers.js";
+import { Http2Connection } from "./connection.js";
+class Http2Client {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  /**
+   * Create an Http2Client from an already-initialized Http2Connection.
+   * Used by auto-negotiation when the TLS socket is already established.
+   */
+  static fromConnection(connection) {
+    return new Http2Client(connection);
+  }
+  /**
+   * Connect to a server and perform HTTP/2 handshake via WASM TLS (with ALPN).
+   * Uses non-blocking SETTINGS: preface is sent immediately, handshake
+   * completes in parallel with the first request's header encoding.
+   */
+  static async connect(hostname, port = 443, tls = true, options = {}, connectHostname, signal) {
+    const socket = tls ? await createWasmTLSSocket(hostname, port, ["h2"], connectHostname, signal) : await createPlainSocket(connectHostname ?? hostname, port);
+    const connection = new Http2Connection(socket, options);
+    await connection.startInitialize();
+    return new Http2Client(connection);
+  }
+  /**
+   * Send an HTTP/2 request and return the response.
+   */
+  async request(url, options = {}) {
+    const parsed = typeof url === "string" ? parseUrl(url) : url;
+    const method = options.method ?? "GET";
+    const pseudo = buildPseudoHeaders(method, parsed.hostname, parsed.path, parsed.protocol);
+    const allHeaders = mergeHeaders(pseudo, options.headers ?? {});
+    const isStreamBody = options.body instanceof ReadableStream;
+    if (options.body && !isStreamBody && options.body.byteLength > 0) {
+      const hasContentLength = allHeaders.some(([name]) => name === "content-length");
+      if (!hasContentLength) {
+        allHeaders.push(["content-length", String(options.body.byteLength)]);
+      }
+    }
+    const stream = this.connection.createStream();
+    if (options.bodyTimeout !== void 0) {
+      stream.setBodyTimeout(options.bodyTimeout);
+    }
+    const hasBody = isStreamBody || options.body && !isStreamBody && options.body.byteLength > 0;
+    await this.connection.sendHeaders(stream, allHeaders, !hasBody);
+    if (hasBody && options.body) {
+      if (isStreamBody) {
+        await this.connection.sendData(stream, options.body, true);
+      } else {
+        await this.connection.sendData(stream, Buffer.from(options.body), true);
+      }
+    }
+    const responseData = await stream.waitForResponse(options.headersTimeout);
+    return {
+      status: responseData.status,
+      headers: responseData.headers,
+      rawHeaders: responseData.rawHeaders,
+      protocol: "h2",
+      body: stream.body
+    };
+  }
+  /** Whether the connection is still usable */
+  get isReady() {
+    return this.connection.isReady;
+  }
+  /** Number of currently active streams */
+  get activeStreamCount() {
+    return this.connection.activeStreamCount;
+  }
+  /** Remote peer's MAX_CONCURRENT_STREAMS */
+  get maxConcurrentStreams() {
+    return this.connection.maxConcurrentStreams;
+  }
+  /** Whether the connection can accept another stream */
+  get hasCapacity() {
+    return this.isReady && this.activeStreamCount < this.maxConcurrentStreams;
+  }
+  /** Register a callback for GOAWAY events */
+  onGoaway(callback) {
+    this.connection.on("goaway", callback);
+  }
+  /** Remove a GOAWAY callback */
+  offGoaway(callback) {
+    this.connection.removeListener("goaway", callback);
+  }
+  /** Close the connection */
+  async close() {
+    await this.connection.close();
+  }
+}
+export {
+  Http2Client
+};

package/dist/http2/connection.d.ts

@@ -0,0 +1,125 @@
+import { Buffer } from 'node:buffer';
+import { EventEmitter } from 'node:events';
+import { Duplex } from 'node:stream';
+import { Http2Stream } from './stream.js';
+import './constants.js';
+import './flow-control.js';
+
+/**
+ * HTTP/2 connection management.
+ * Handles the full lifecycle: preface, SETTINGS exchange, frame dispatch,
+ * stream creation, and graceful shutdown.
+ */
+
+interface ConnectionOptions {
+    /** Maximum header table size for HPACK (default: 1024 to save CPU) */
+    headerTableSize?: number;
+    /** Initial stream window size for flow control (default: 2 MiB) */
+    initialWindowSize?: number;
+    /** Connection-level receive window size (default: 4 MiB) */
+    connectionWindowSize?: number;
+    /** Timeout for SETTINGS exchange in ms (default: 5000) */
+    settingsTimeout?: number;
+}
+/**
+ * HTTP/2 connection over a raw socket.
+ * Call initialize() after construction to perform the h2 handshake.
+ */
+declare class Http2Connection extends EventEmitter {
+    private socket;
+    private parser;
+    private hpackEncoder;
+    private hpackDecoder;
+    private remoteSettings;
+    private localSettings;
+    private nextStreamId;
+    private streams;
+    private connectionSendWindow;
+    private connectionRecvWindowSize;
+    private connectionRecvWindowConsumed;
+    private goawayReceived;
+    private goawaySent;
+    private initialized;
+    private closed;
+    private lastRemoteInitialWindowSize;
+    private pendingWrites;
+    private flushScheduled;
+    private flushPromiseResolvers;
+    private settingsAckResolve;
+    private remoteSettingsResolve;
+    private readyPromise;
+    private settingsTimeout;
+    private continuationStreamId;
+    private continuationBuffer;
+    private continuationBufferSize;
+    private continuationEndStream;
+    constructor(socket: Duplex, options?: ConnectionOptions);
+    /**
+     * Initialize the HTTP/2 connection.
+     * Sends connection preface + SETTINGS, waits for peer SETTINGS + ACK.
+     */
+    initialize(timeout?: number): Promise<void>;
+    /**
+     * Non-blocking initialization: sends connection preface + SETTINGS
+     * immediately without waiting for the peer's response.
+     * Call waitForReady() before sending the first request.
+     */
+    startInitialize(): Promise<void>;
+    /**
+     * Wait for the peer's SETTINGS + ACK to complete the handshake.
+     * Must be called after startInitialize().
+     */
+    waitForReady(timeout?: number): Promise<void>;
+    /**
+     * Create a new HTTP/2 stream for a request.
+     */
+    createStream(): Http2Stream;
+    /**
+     * Send HEADERS frame for a stream.
+     * Handles CONTINUATION if header block exceeds max frame size.
+     * Auto-waits for SETTINGS exchange if not yet complete.
+     */
+    sendHeaders(stream: Http2Stream, headers: Array<[string, string]>, endStream: boolean): Promise<void>;
+    /**
+     * Send DATA frame(s) for a stream, respecting flow control.
+     * Accepts Buffer (buffered) or ReadableStream (streaming).
+     */
+    sendData(stream: Http2Stream, data: Buffer | ReadableStream<Uint8Array>, endStream: boolean): Promise<void>;
+    private sendBufferData;
+    /** Stream a ReadableStream body as DATA frames with flow control (pull model). */
+    private sendStreamData;
+    /**
+     * Gracefully close the connection.
+     */
+    close(): Promise<void>;
+    private handleFrame;
+    private handleDataFrame;
+    private handleHeadersFrame;
+    private processHeaderBlock;
+    private handleSettingsFrame;
+    private handleWindowUpdateFrame;
+    private handlePingFrame;
+    private handleGoawayFrame;
+    private handleRstStreamFrame;
+    /** Send GOAWAY with given error code and close the connection. */
+    private sendGoawayAndClose;
+    private handleError;
+    private handleSocketClose;
+    /**
+     * Queue a frame for writing. Frames queued in the same microtask
+     * are coalesced into a single socket.write() call.
+     */
+    private writeRaw;
+    /** Flush all pending writes as a single socket.write(). */
+    private flush;
+    /** Write multiple frames as a single socket.write() immediately (no microtask delay). */
+    private writeMulti;
+    /** Whether the connection has been initialized and is usable */
+    get isReady(): boolean;
+    /** Number of currently active (open) streams */
+    get activeStreamCount(): number;
+    /** Remote peer's MAX_CONCURRENT_STREAMS setting (default: 100) */
+    get maxConcurrentStreams(): number;
+}
+
+export { type ConnectionOptions, Http2Connection };