@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/http-request.js

@@ -1,761 +0,0 @@
-"use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var http_request_exports = {};
-__export(http_request_exports, {
-  HttpResponseError: () => HttpResponseError,
-  enrichErrorMessage: () => enrichErrorMessage,
-  fetchChecksums: () => fetchChecksums,
-  httpDownload: () => httpDownload,
-  httpJson: () => httpJson,
-  httpRequest: () => httpRequest,
-  httpText: () => httpText,
-  parseChecksums: () => parseChecksums,
-  parseRetryAfterHeader: () => parseRetryAfterHeader,
-  readIncomingResponse: () => readIncomingResponse,
-  sanitizeHeaders: () => sanitizeHeaders
-});
-module.exports = __toCommonJS(http_request_exports);
-var import_promises = require("node:timers/promises");
-var import_socket = require("./constants/socket");
-var import_fs = require("./fs");
-var import_primordials = require("./primordials");
-class HttpResponseError extends Error {
-  response;
-  constructor(response, message) {
-    const statusCode = response.status ?? "unknown";
-    const statusMessage = response.statusText || "No status message";
-    super(message ?? `HTTP ${statusCode}: ${statusMessage}`);
-    this.name = "HttpResponseError";
-    this.response = response;
-    Error.captureStackTrace(this, HttpResponseError);
-  }
-}
-let _fs;
-let _crypto;
-let _http;
-let _https;
-// @__NO_SIDE_EFFECTS__
-function getCrypto() {
-  if (_crypto === void 0) {
-    _crypto = require("node:crypto");
-  }
-  return _crypto;
-}
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-// @__NO_SIDE_EFFECTS__
-function getHttp() {
-  if (_http === void 0) {
-    _http = require("node:http");
-  }
-  return _http;
-}
-// @__NO_SIDE_EFFECTS__
-function getHttps() {
-  if (_https === void 0) {
-    _https = require("node:https");
-  }
-  return _https;
-}
-async function httpDownloadAttempt(url, destPath, options) {
-  const {
-    ca,
-    followRedirects = true,
-    headers = {},
-    maxRedirects = 5,
-    onProgress,
-    timeout = 12e4
-  } = { __proto__: null, ...options };
-  const response = await httpRequestAttempt(url, {
-    ca,
-    followRedirects,
-    headers,
-    maxRedirects,
-    method: "GET",
-    stream: true,
-    timeout
-  });
-  if (!response.ok) {
-    throw new HttpResponseError(
-      response,
-      `Download failed: HTTP ${response.status} ${response.statusText}`
-    );
-  }
-  const res = response.rawResponse;
-  if (!res) {
-    throw new import_primordials.ErrorCtor("Stream response missing rawResponse");
-  }
-  const { createWriteStream } = /* @__PURE__ */ getFs();
-  const totalSize = (0, import_primordials.NumberParseInt)(
-    response.headers["content-length"] || "0",
-    10
-  );
-  return await new import_primordials.PromiseCtor((resolve, reject) => {
-    let downloadedSize = 0;
-    const fileStream = createWriteStream(destPath);
-    const cleanupPartial = () => {
-      ;
-      (async () => {
-        try {
-          await (/* @__PURE__ */ getFs()).promises.unlink(destPath);
-        } catch {
-        }
-      })();
-    };
-    fileStream.on("error", (error) => {
-      fileStream.destroy();
-      cleanupPartial();
-      reject(
-        new Error(`Failed to write file: ${error.message}`, { cause: error })
-      );
-    });
-    res.on("data", (chunk) => {
-      downloadedSize += chunk.length;
-      if (onProgress && totalSize > 0) {
-        onProgress(downloadedSize, totalSize);
-      }
-    });
-    res.on("end", () => {
-      fileStream.close(() => {
-        resolve({
-          headers: response.headers,
-          ok: true,
-          path: destPath,
-          size: downloadedSize,
-          status: response.status,
-          statusText: response.statusText
-        });
-      });
-    });
-    res.on("error", (error) => {
-      fileStream.destroy();
-      cleanupPartial();
-      reject(error);
-    });
-    res.pipe(fileStream);
-  });
-}
-async function httpRequestAttempt(url, options) {
-  const {
-    body,
-    ca,
-    followRedirects = true,
-    headers = {},
-    hooks,
-    maxRedirects = 5,
-    maxResponseSize,
-    method = "GET",
-    stream = false,
-    timeout = 3e4
-  } = { __proto__: null, ...options };
-  const startTime = (0, import_primordials.DateNow)();
-  const streamHeaders = body && typeof body === "object" && "getHeaders" in body && typeof body.getHeaders === "function" ? body.getHeaders() : void 0;
-  const mergedHeaders = {
-    "User-Agent": import_socket.SOCKET_LIB_USER_AGENT,
-    ...streamHeaders,
-    ...headers
-  };
-  hooks?.onRequest?.({ method, url, headers: mergedHeaders, timeout });
-  return await new import_primordials.PromiseCtor((resolve, reject) => {
-    let settled = false;
-    const resolveOnce = (response) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolve(response);
-    };
-    const rejectOnce = (err) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (body && typeof body === "object" && typeof body.destroy === "function") {
-        ;
-        body.destroy();
-      }
-      emitResponse({ error: err });
-      reject(err);
-    };
-    const parsedUrl = new import_primordials.URLCtor(url);
-    const isHttps = parsedUrl.protocol === "https:";
-    const httpModule = isHttps ? /* @__PURE__ */ getHttps() : /* @__PURE__ */ getHttp();
-    const requestOptions = {
-      headers: mergedHeaders,
-      hostname: parsedUrl.hostname,
-      method,
-      path: parsedUrl.pathname + parsedUrl.search,
-      port: parsedUrl.port,
-      timeout
-    };
-    if (ca && isHttps) {
-      requestOptions["ca"] = ca;
-    }
-    const emitResponse = (info) => {
-      try {
-        hooks?.onResponse?.({
-          duration: (0, import_primordials.DateNow)() - startTime,
-          method,
-          url,
-          ...info
-        });
-      } catch {
-      }
-    };
-    const request = httpModule.request(
-      requestOptions,
-      (res) => {
-        if (followRedirects && res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          res.resume();
-          emitResponse({
-            headers: res.headers,
-            status: res.statusCode,
-            statusText: res.statusMessage
-          });
-          if (maxRedirects <= 0) {
-            settled = true;
-            reject(
-              new Error(
-                `Too many redirects (exceeded maximum: ${maxRedirects})`
-              )
-            );
-            return;
-          }
-          const redirectUrl = res.headers.location.startsWith("http") ? res.headers.location : new URL(res.headers.location, url).toString();
-          const redirectParsed = new URL(redirectUrl);
-          if (isHttps && redirectParsed.protocol !== "https:") {
-            settled = true;
-            reject(
-              new Error(
-                `Redirect from HTTPS to HTTP is not allowed: ${redirectUrl}`
-              )
-            );
-            return;
-          }
-          let redirectHeaders = headers;
-          if (new URL(url).origin !== redirectParsed.origin) {
-            redirectHeaders = { __proto__: null };
-            const stripped = /* @__PURE__ */ new Set([
-              "authorization",
-              "cookie",
-              "proxy-authorization",
-              "proxy-authenticate"
-            ]);
-            for (const key of Object.keys(headers)) {
-              if (!stripped.has(key.toLowerCase())) {
-                ;
-                redirectHeaders[key] = headers[key];
-              }
-            }
-          }
-          settled = true;
-          resolve(
-            httpRequestAttempt(redirectUrl, {
-              body,
-              ca,
-              followRedirects,
-              headers: redirectHeaders,
-              hooks,
-              maxRedirects: maxRedirects - 1,
-              maxResponseSize,
-              method,
-              stream,
-              timeout
-            })
-          );
-          return;
-        }
-        if (stream) {
-          const status = res.statusCode || 0;
-          const statusText = res.statusMessage || "";
-          const ok = status >= 200 && status < 300;
-          emitResponse({
-            headers: res.headers,
-            status,
-            statusText
-          });
-          const emptyBody = Buffer.alloc(0);
-          resolveOnce({
-            arrayBuffer: () => emptyBody.buffer,
-            body: emptyBody,
-            headers: res.headers,
-            json: () => {
-              throw new Error("Cannot parse JSON from a streaming response");
-            },
-            ok,
-            rawResponse: res,
-            status,
-            statusText,
-            text: () => ""
-          });
-          return;
-        }
-        const chunks = [];
-        let totalBytes = 0;
-        res.on("data", (chunk) => {
-          totalBytes += chunk.length;
-          if (maxResponseSize && totalBytes > maxResponseSize) {
-            res.destroy();
-            request.destroy();
-            const sizeMB = (totalBytes / (1024 * 1024)).toFixed(2);
-            const maxMB = (maxResponseSize / (1024 * 1024)).toFixed(2);
-            rejectOnce(
-              new Error(
-                `Response exceeds maximum size limit (${sizeMB}MB > ${maxMB}MB)`
-              )
-            );
-            return;
-          }
-          chunks.push(chunk);
-        });
-        res.on("end", () => {
-          if (settled) {
-            return;
-          }
-          const responseBody = Buffer.concat(chunks);
-          const ok = res.statusCode !== void 0 && res.statusCode >= 200 && res.statusCode < 300;
-          const response = {
-            arrayBuffer() {
-              return responseBody.buffer.slice(
-                responseBody.byteOffset,
-                responseBody.byteOffset + responseBody.byteLength
-              );
-            },
-            body: responseBody,
-            headers: res.headers,
-            json() {
-              return JSON.parse(responseBody.toString("utf8"));
-            },
-            ok,
-            rawResponse: res,
-            status: res.statusCode || 0,
-            statusText: res.statusMessage || "",
-            text() {
-              return responseBody.toString("utf8");
-            }
-          };
-          emitResponse({
-            headers: res.headers,
-            status: res.statusCode,
-            statusText: res.statusMessage
-          });
-          resolveOnce(response);
-        });
-        res.on("error", (error) => {
-          rejectOnce(error);
-        });
-      }
-    );
-    request.on("error", (error) => {
-      const message = enrichErrorMessage(
-        url,
-        method,
-        error
-      );
-      rejectOnce(new Error(message, { cause: error }));
-    });
-    request.on("timeout", () => {
-      request.destroy();
-      rejectOnce(
-        new Error(
-          `${method} request timed out after ${timeout}ms: ${url}
-\u2192 Server did not respond in time.
-\u2192 Try: Increase timeout or check network connectivity.`
-        )
-      );
-    });
-    if (body) {
-      if (typeof body === "object" && typeof body.pipe === "function") {
-        const stream2 = body;
-        stream2.on("error", (err) => {
-          request.destroy();
-          rejectOnce(err);
-        });
-        stream2.pipe(request);
-        return;
-      }
-      request.write(body);
-      request.end();
-    } else {
-      request.end();
-    }
-  });
-}
-function enrichErrorMessage(url, method, error) {
-  const code = error.code;
-  let message = `${method} request failed: ${url}`;
-  if (code === "ECONNREFUSED") {
-    message += "\n\u2192 Connection refused. Server is unreachable.\n\u2192 Check: Network connectivity and firewall settings.";
-  } else if (code === "ENOTFOUND") {
-    message += "\n\u2192 DNS lookup failed. Cannot resolve hostname.\n\u2192 Check: Internet connection and DNS settings.";
-  } else if (code === "ETIMEDOUT") {
-    message += "\n\u2192 Connection timed out. Network or server issue.\n\u2192 Try: Check network connectivity and retry.";
-  } else if (code === "ECONNRESET") {
-    message += "\n\u2192 Connection reset by server. Possible network interruption.\n\u2192 Try: Retry the request.";
-  } else if (code === "EPIPE") {
-    message += "\n\u2192 Broken pipe. Server closed connection unexpectedly.\n\u2192 Check: Authentication credentials and permissions.";
-  } else if (code === "CERT_HAS_EXPIRED" || code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE") {
-    message += "\n\u2192 SSL/TLS certificate error.\n\u2192 Check: System time and date are correct.\n\u2192 Try: Update CA certificates on your system.";
-  } else if (code) {
-    message += `
-\u2192 Error code: ${code}`;
-  }
-  return message;
-}
-async function fetchChecksums(url, options) {
-  const {
-    ca,
-    headers = {},
-    timeout = 3e4
-  } = {
-    __proto__: null,
-    ...options
-  };
-  const response = await httpRequest(url, { ca, headers, timeout });
-  if (!response.ok) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to fetch checksums from ${url}: ${response.status} ${response.statusText}`
-    );
-  }
-  return parseChecksums(response.body.toString("utf8"));
-}
-async function httpDownload(url, destPath, options) {
-  const {
-    ca,
-    followRedirects = true,
-    headers = {},
-    logger,
-    maxRedirects = 5,
-    onProgress,
-    progressInterval = 10,
-    retries = 0,
-    retryDelay = 1e3,
-    sha256,
-    timeout = 12e4
-  } = { __proto__: null, ...options };
-  let progressCallback;
-  if (onProgress) {
-    progressCallback = onProgress;
-  } else if (logger) {
-    let lastPercent = 0;
-    progressCallback = (downloaded, total) => {
-      const percent = total === 0 ? 0 : (0, import_primordials.MathFloor)(downloaded / total * 100);
-      if (percent >= lastPercent + progressInterval) {
-        logger.log(
-          `  Progress: ${percent}% (${(downloaded / 1024 / 1024).toFixed(1)} MB / ${(total / 1024 / 1024).toFixed(1)} MB)`
-        );
-        lastPercent = percent;
-      }
-    };
-  }
-  const crypto = /* @__PURE__ */ getCrypto();
-  const fs = /* @__PURE__ */ getFs();
-  const tempSuffix = crypto.randomBytes(6).toString("hex");
-  const tempPath = `${destPath}.${tempSuffix}.download`;
-  if (fs.existsSync(tempPath)) {
-    await (0, import_fs.safeDelete)(tempPath);
-  }
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      const result = await httpDownloadAttempt(url, tempPath, {
-        ca,
-        followRedirects,
-        headers,
-        maxRedirects,
-        onProgress: progressCallback,
-        timeout
-      });
-      if (sha256) {
-        const fileContent = await fs.promises.readFile(tempPath);
-        const computedHash = crypto.createHash("sha256").update(fileContent).digest("hex");
-        const expectedHash = sha256.toLowerCase();
-        if (computedHash.length !== expectedHash.length || !crypto.timingSafeEqual(
-          (0, import_primordials.BufferFrom)(computedHash),
-          Buffer.from(expectedHash)
-        )) {
-          await (0, import_fs.safeDelete)(tempPath);
-          throw new import_primordials.ErrorCtor(
-            `Checksum verification failed for ${url}
-Expected: ${expectedHash}
-Computed: ${computedHash}`
-          );
-        }
-      }
-      await fs.promises.rename(tempPath, destPath);
-      return {
-        ...result,
-        path: destPath
-      };
-    } catch (e) {
-      lastError = e;
-      if (fs.existsSync(tempPath)) {
-        await (0, import_fs.safeDelete)(tempPath);
-      }
-      if (attempt === retries) {
-        break;
-      }
-      const delayMs = retryDelay * 2 ** attempt;
-      await (0, import_promises.setTimeout)(delayMs);
-    }
-  }
-  throw lastError || new import_primordials.ErrorCtor("Download failed after retries");
-}
-async function httpJson(url, options) {
-  const {
-    body,
-    headers = {},
-    ...restOptions
-  } = {
-    __proto__: null,
-    ...options
-  };
-  const defaultHeaders = {
-    Accept: "application/json"
-  };
-  if (body) {
-    defaultHeaders["Content-Type"] = "application/json";
-  }
-  const mergedHeaders = {
-    ...defaultHeaders,
-    ...headers
-  };
-  const response = await httpRequest(url, {
-    body,
-    headers: mergedHeaders,
-    ...restOptions
-  });
-  if (!response.ok) {
-    throw new HttpResponseError(response);
-  }
-  try {
-    return response.json();
-  } catch (e) {
-    throw new import_primordials.ErrorCtor("Failed to parse JSON response", { cause: e });
-  }
-}
-async function httpRequest(url, options) {
-  const {
-    body,
-    ca,
-    followRedirects = true,
-    headers = {},
-    hooks,
-    maxRedirects = 5,
-    maxResponseSize,
-    method = "GET",
-    onRetry,
-    retries = 0,
-    retryDelay = 1e3,
-    stream = false,
-    throwOnError = false,
-    timeout = 3e4
-  } = { __proto__: null, ...options };
-  const isStreamBody = body !== void 0 && typeof body === "object" && typeof body.pipe === "function";
-  if (isStreamBody && retries > 0) {
-    throw new import_primordials.ErrorCtor(
-      "Streaming body (Readable/FormData) cannot be used with retries. Streams are consumed on first attempt and cannot be replayed. Set retries: 0 or buffer the body as a string/Buffer."
-    );
-  }
-  const attemptOpts = {
-    body,
-    ca,
-    // Disable redirect following for stream bodies — the stream is consumed
-    // on the first request and cannot be re-piped to the redirect target.
-    followRedirects: isStreamBody ? false : followRedirects,
-    headers,
-    hooks,
-    maxRedirects,
-    maxResponseSize,
-    method,
-    stream,
-    timeout
-  };
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      const response = await httpRequestAttempt(url, attemptOpts);
-      if (throwOnError && !response.ok) {
-        throw new HttpResponseError(response);
-      }
-      return response;
-    } catch (e) {
-      lastError = e;
-      if (attempt === retries) {
-        break;
-      }
-      const delayMs = retryDelay * 2 ** attempt;
-      if (onRetry) {
-        const retryResult = onRetry(attempt + 1, e, delayMs);
-        if (retryResult === false) {
-          break;
-        }
-        const actualDelay = typeof retryResult === "number" && !(0, import_primordials.NumberIsNaN)(retryResult) ? (0, import_primordials.MathMax)(0, retryResult) : delayMs;
-        await (0, import_promises.setTimeout)(actualDelay);
-      } else {
-        await (0, import_promises.setTimeout)(delayMs);
-      }
-    }
-  }
-  throw lastError || new import_primordials.ErrorCtor("Request failed after retries");
-}
-async function httpText(url, options) {
-  const {
-    body,
-    headers = {},
-    ...restOptions
-  } = {
-    __proto__: null,
-    ...options
-  };
-  const defaultHeaders = {
-    Accept: "text/plain"
-  };
-  if (body) {
-    defaultHeaders["Content-Type"] = "text/plain";
-  }
-  const mergedHeaders = {
-    ...defaultHeaders,
-    ...headers
-  };
-  const response = await httpRequest(url, {
-    body,
-    headers: mergedHeaders,
-    ...restOptions
-  });
-  if (!response.ok) {
-    throw new HttpResponseError(response);
-  }
-  return response.text();
-}
-const CHECKSUM_BSD_RE = /^SHA256\s+\((.+)\)\s+=\s+([a-fA-F0-9]{64})$/;
-const CHECKSUM_GNU_RE = /^([a-fA-F0-9]{64})\s+(.+)$/;
-const RETRY_AFTER_INT_RE = /^\d+$/;
-function parseChecksums(text) {
-  const checksums = { __proto__: null };
-  for (const line of (0, import_primordials.StringPrototypeSplit)(text, "\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || (0, import_primordials.StringPrototypeStartsWith)(trimmed, "#")) {
-      continue;
-    }
-    const bsdMatch = CHECKSUM_BSD_RE.exec(trimmed);
-    if (bsdMatch) {
-      checksums[bsdMatch[1]] = bsdMatch[2].toLowerCase();
-      continue;
-    }
-    const gnuMatch = CHECKSUM_GNU_RE.exec(trimmed);
-    if (gnuMatch) {
-      checksums[gnuMatch[2]] = gnuMatch[1].toLowerCase();
-    }
-  }
-  return checksums;
-}
-function parseRetryAfterHeader(value) {
-  if (!value) {
-    return void 0;
-  }
-  const raw = (0, import_primordials.ArrayIsArray)(value) ? value[0] : value;
-  if (!raw) {
-    return void 0;
-  }
-  const trimmed = raw.trim();
-  if (RETRY_AFTER_INT_RE.test(trimmed)) {
-    const seconds = Number(trimmed);
-    return seconds * 1e3;
-  }
-  const date = new import_primordials.DateCtor(raw);
-  if (!(0, import_primordials.NumberIsNaN)(date.getTime())) {
-    const delayMs = date.getTime() - (0, import_primordials.DateNow)();
-    if (delayMs > 0) {
-      return delayMs;
-    }
-  }
-  return void 0;
-}
-async function readIncomingResponse(msg) {
-  const chunks = [];
-  for await (const chunk of msg) {
-    chunks.push(chunk);
-  }
-  const body = (0, import_primordials.BufferConcat)(chunks);
-  const status = msg.statusCode ?? 0;
-  const statusText = msg.statusMessage ?? "";
-  return {
-    arrayBuffer: () => body.buffer.slice(
-      body.byteOffset,
-      body.byteOffset + body.byteLength
-    ),
-    body,
-    headers: msg.headers,
-    json: () => (0, import_primordials.JSONParse)(body.toString("utf8")),
-    ok: status >= 200 && status < 300,
-    rawResponse: msg,
-    status,
-    statusText,
-    text: () => body.toString("utf8")
-  };
-}
-function sanitizeHeaders(headers) {
-  if (!headers) {
-    return {};
-  }
-  const sensitiveHeaders = new import_primordials.SetCtor([
-    "authorization",
-    "cookie",
-    "proxy-authorization",
-    "proxy-authenticate",
-    "set-cookie",
-    "www-authenticate"
-  ]);
-  const result = {
-    __proto__: null
-  };
-  for (const key of (0, import_primordials.ObjectKeys)(headers)) {
-    const value = headers[key];
-    if (sensitiveHeaders.has(key.toLowerCase())) {
-      result[key] = "[REDACTED]";
-    } else if ((0, import_primordials.ArrayIsArray)(value)) {
-      result[key] = value.join(", ");
-    } else if (value !== void 0 && value !== null) {
-      result[key] = String(value);
-    }
-  }
-  return result;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  HttpResponseError,
-  enrichErrorMessage,
-  fetchChecksums,
-  httpDownload,
-  httpJson,
-  httpRequest,
-  httpText,
-  parseChecksums,
-  parseRetryAfterHeader,
-  readIncomingResponse,
-  sanitizeHeaders
-});