httpcloak 1.0.0

package/README.md

@@ -0,0 +1,209 @@
+# HTTPCloak Node.js
+
+Browser fingerprint emulation HTTP client with HTTP/1.1, HTTP/2, and HTTP/3 support.
+
+## Installation
+
+```bash
+npm install httpcloak
+```
+
+## Quick Start
+
+### Promise-based Usage (Recommended)
+
+```javascript
+const { Session } = require("httpcloak");
+
+async function main() {
+  const session = new Session({ preset: "chrome-143" });
+
+  try {
+    // GET request
+    const response = await session.get("https://www.cloudflare.com/cdn-cgi/trace");
+    console.log(response.statusCode);
+    console.log(response.text);
+
+    // POST request with JSON body
+    const postResponse = await session.post("https://api.example.com/data", {
+      key: "value",
+    });
+
+    // Custom headers
+    const customResponse = await session.get("https://example.com", {
+      "X-Custom": "value",
+    });
+
+    // Concurrent requests
+    const responses = await Promise.all([
+      session.get("https://example.com/1"),
+      session.get("https://example.com/2"),
+      session.get("https://example.com/3"),
+    ]);
+  } finally {
+    session.close();
+  }
+}
+
+main();
+```
+
+### Synchronous Usage
+
+```javascript
+const { Session } = require("httpcloak");
+
+const session = new Session({ preset: "chrome-143" });
+
+// Sync GET
+const response = session.getSync("https://example.com");
+console.log(response.statusCode);
+console.log(response.text);
+
+// Sync POST
+const postResponse = session.postSync("https://api.example.com/data", {
+  key: "value",
+});
+
+session.close();
+```
+
+### Callback-based Usage
+
+```javascript
+const { Session } = require("httpcloak");
+
+const session = new Session({ preset: "chrome-143" });
+
+// GET with callback
+session.getCb("https://example.com", (err, response) => {
+  if (err) {
+    console.error("Error:", err.message);
+    return;
+  }
+  console.log(response.statusCode);
+  console.log(response.text);
+});
+
+// POST with callback
+session.postCb(
+  "https://api.example.com/data",
+  { key: "value" },
+  (err, response) => {
+    if (err) {
+      console.error("Error:", err.message);
+      return;
+    }
+    console.log(response.statusCode);
+  }
+);
+```
+
+### With Proxy
+
+```javascript
+const session = new Session({
+  preset: "chrome-143",
+  proxy: "http://user:pass@host:port",
+});
+```
+
+## Cookie Management
+
+```javascript
+const { Session } = require("httpcloak");
+
+const session = new Session();
+
+// Get all cookies
+const cookies = session.getCookies();
+console.log(cookies);
+
+// Set a cookie
+session.setCookie("session_id", "abc123");
+
+// Access cookies as property
+console.log(session.cookies);
+
+session.close();
+```
+
+## Available Presets
+
+```javascript
+const { availablePresets } = require("httpcloak");
+
+console.log(availablePresets());
+// ['chrome-143', 'chrome-143-windows', 'chrome-143-linux', 'chrome-143-macos',
+//  'chrome-131', 'firefox-133', 'safari-18', ...]
+```
+
+## Response Object
+
+```javascript
+const response = await session.get("https://example.com");
+
+response.statusCode; // number: HTTP status code
+response.headers; // object: Response headers
+response.body; // Buffer: Raw response body
+response.text; // string: Response body as text
+response.finalUrl; // string: Final URL after redirects
+response.protocol; // string: Protocol used (http/1.1, h2, h3)
+response.json(); // Parse response body as JSON
+```
+
+## Custom Requests
+
+```javascript
+const response = await session.request({
+  method: "PUT",
+  url: "https://api.example.com/resource",
+  headers: { "X-Custom": "value" },
+  body: { data: "value" },
+  timeout: 60,
+});
+```
+
+## Error Handling
+
+```javascript
+const { Session, HTTPCloakError } = require("httpcloak");
+
+const session = new Session();
+
+try {
+  const response = await session.get("https://example.com");
+} catch (err) {
+  if (err instanceof HTTPCloakError) {
+    console.error("HTTPCloak error:", err.message);
+  } else {
+    console.error("Unknown error:", err);
+  }
+}
+
+session.close();
+```
+
+## TypeScript Support
+
+HTTPCloak includes TypeScript definitions out of the box:
+
+```typescript
+import { Session, Response, HTTPCloakError } from "httpcloak";
+
+const session = new Session({ preset: "chrome-143" });
+
+async function fetchData(): Promise<Response> {
+  return session.get("https://example.com");
+}
+```
+
+## Platform Support
+
+- Linux (x64, arm64)
+- macOS (x64, arm64)
+- Windows (x64, arm64)
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,152 @@
+/**
+ * HTTPCloak Node.js TypeScript Definitions
+ */
+
+export class HTTPCloakError extends Error {
+  name: "HTTPCloakError";
+}
+
+export class Response {
+  /** HTTP status code */
+  statusCode: number;
+  /** Response headers */
+  headers: Record<string, string>;
+  /** Raw response body as Buffer */
+  body: Buffer;
+  /** Response body as string */
+  text: string;
+  /** Final URL after redirects */
+  finalUrl: string;
+  /** Protocol used (http/1.1, h2, h3) */
+  protocol: string;
+
+  /** Parse response body as JSON */
+  json<T = any>(): T;
+}
+
+export interface SessionOptions {
+  /** Browser preset to use (default: "chrome-143") */
+  preset?: string;
+  /** Proxy URL (e.g., "http://user:pass@host:port") */
+  proxy?: string;
+  /** Request timeout in seconds (default: 30) */
+  timeout?: number;
+}
+
+export interface RequestOptions {
+  /** HTTP method */
+  method: string;
+  /** Request URL */
+  url: string;
+  /** Optional custom headers */
+  headers?: Record<string, string>;
+  /** Optional request body */
+  body?: string | Buffer | Record<string, any>;
+  /** Optional request timeout in seconds */
+  timeout?: number;
+}
+
+export type RequestCallback = (
+  error: HTTPCloakError | null,
+  response: Response | null
+) => void;
+
+export class Session {
+  constructor(options?: SessionOptions);
+
+  /** Close the session and release resources */
+  close(): void;
+
+  // Synchronous methods
+  /** Perform a synchronous GET request */
+  getSync(url: string, headers?: Record<string, string>): Response;
+
+  /** Perform a synchronous POST request */
+  postSync(
+    url: string,
+    body?: string | Buffer | Record<string, any>,
+    headers?: Record<string, string>
+  ): Response;
+
+  /** Perform a synchronous custom HTTP request */
+  requestSync(options: RequestOptions): Response;
+
+  // Promise-based methods
+  /** Perform an async GET request */
+  get(url: string, headers?: Record<string, string>): Promise<Response>;
+
+  /** Perform an async POST request */
+  post(
+    url: string,
+    body?: string | Buffer | Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<Response>;
+
+  /** Perform an async custom HTTP request */
+  request(options: RequestOptions): Promise<Response>;
+
+  /** Perform an async PUT request */
+  put(
+    url: string,
+    body?: string | Buffer | Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<Response>;
+
+  /** Perform an async DELETE request */
+  delete(url: string, headers?: Record<string, string>): Promise<Response>;
+
+  /** Perform an async PATCH request */
+  patch(
+    url: string,
+    body?: string | Buffer | Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<Response>;
+
+  /** Perform an async HEAD request */
+  head(url: string, headers?: Record<string, string>): Promise<Response>;
+
+  /** Perform an async OPTIONS request */
+  options(url: string, headers?: Record<string, string>): Promise<Response>;
+
+  // Callback-based methods
+  /** Perform a GET request with callback */
+  getCb(url: string, callback: RequestCallback): void;
+  getCb(
+    url: string,
+    headers: Record<string, string>,
+    callback: RequestCallback
+  ): void;
+
+  /** Perform a POST request with callback */
+  postCb(url: string, callback: RequestCallback): void;
+  postCb(
+    url: string,
+    body: string | Buffer | Record<string, any>,
+    callback: RequestCallback
+  ): void;
+  postCb(
+    url: string,
+    body: string | Buffer | Record<string, any>,
+    headers: Record<string, string>,
+    callback: RequestCallback
+  ): void;
+
+  /** Perform a custom request with callback */
+  requestCb(options: RequestOptions, callback: RequestCallback): void;
+
+  // Cookie management
+  /** Get all cookies from the session */
+  getCookies(): Record<string, string>;
+
+  /** Set a cookie in the session */
+  setCookie(name: string, value: string): void;
+
+  /** Get cookies as a property */
+  readonly cookies: Record<string, string>;
+}
+
+/** Get the httpcloak library version */
+export function version(): string;
+
+/** Get list of available browser presets */
+export function availablePresets(): string[];

package/lib/index.js

@@ -0,0 +1,551 @@
+/**
+ * HTTPCloak Node.js Client
+ *
+ * Provides HTTP client with browser fingerprint emulation.
+ */
+
+const koffi = require("koffi");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+
+/**
+ * Custom error class for HTTPCloak errors
+ */
+class HTTPCloakError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HTTPCloakError";
+  }
+}
+
+/**
+ * Response object returned from HTTP requests
+ */
+class Response {
+  constructor(data) {
+    this.statusCode = data.status_code || 0;
+    this.headers = data.headers || {};
+    this.body = Buffer.from(data.body || "", "utf8");
+    this.text = data.body || "";
+    this.finalUrl = data.final_url || "";
+    this.protocol = data.protocol || "";
+  }
+
+  /**
+   * Parse response body as JSON
+   */
+  json() {
+    return JSON.parse(this.text);
+  }
+}
+
+/**
+ * Get the platform package name for the current platform
+ */
+function getPlatformPackageName() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  // Map to npm platform names
+  let platName;
+  if (platform === "darwin") {
+    platName = "darwin";
+  } else if (platform === "win32") {
+    platName = "win32";
+  } else {
+    platName = "linux";
+  }
+
+  let archName;
+  if (arch === "x64" || arch === "amd64") {
+    archName = "x64";
+  } else if (arch === "arm64" || arch === "aarch64") {
+    archName = "arm64";
+  } else {
+    archName = arch;
+  }
+
+  return `@httpcloak/${platName}-${archName}`;
+}
+
+/**
+ * Get the path to the native library
+ */
+function getLibPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  // Check environment variable first
+  const envPath = process.env.HTTPCLOAK_LIB_PATH;
+  if (envPath && fs.existsSync(envPath)) {
+    return envPath;
+  }
+
+  // Try to load from platform-specific optional dependency
+  const packageName = getPlatformPackageName();
+  try {
+    const libPath = require(packageName);
+    if (fs.existsSync(libPath)) {
+      return libPath;
+    }
+  } catch (e) {
+    // Optional dependency not installed, fall back to local search
+  }
+
+  // Normalize architecture for library name
+  let archName;
+  if (arch === "x64" || arch === "amd64") {
+    archName = "amd64";
+  } else if (arch === "arm64" || arch === "aarch64") {
+    archName = "arm64";
+  } else {
+    archName = arch;
+  }
+
+  // Determine OS name and extension
+  let osName, ext;
+  if (platform === "darwin") {
+    osName = "darwin";
+    ext = ".dylib";
+  } else if (platform === "win32") {
+    osName = "windows";
+    ext = ".dll";
+  } else {
+    osName = "linux";
+    ext = ".so";
+  }
+
+  const libName = `libhttpcloak-${osName}-${archName}${ext}`;
+
+  // Search paths (fallback for local development)
+  const searchPaths = [
+    path.join(__dirname, libName),
+    path.join(__dirname, "..", libName),
+    path.join(__dirname, "..", "lib", libName),
+  ];
+
+  for (const searchPath of searchPaths) {
+    if (fs.existsSync(searchPath)) {
+      return searchPath;
+    }
+  }
+
+  throw new HTTPCloakError(
+    `Could not find httpcloak library (${libName}). ` +
+      `Try: npm install ${packageName}`
+  );
+}
+
+// Load the native library
+let lib = null;
+
+function getLib() {
+  if (lib === null) {
+    const libPath = getLibPath();
+    const nativeLib = koffi.load(libPath);
+
+    lib = {
+      httpcloak_session_new: nativeLib.func("httpcloak_session_new", "int64", ["str"]),
+      httpcloak_session_free: nativeLib.func("httpcloak_session_free", "void", ["int64"]),
+      httpcloak_get: nativeLib.func("httpcloak_get", "str", ["int64", "str", "str"]),
+      httpcloak_post: nativeLib.func("httpcloak_post", "str", ["int64", "str", "str", "str"]),
+      httpcloak_request: nativeLib.func("httpcloak_request", "str", ["int64", "str"]),
+      httpcloak_get_cookies: nativeLib.func("httpcloak_get_cookies", "str", ["int64"]),
+      httpcloak_set_cookie: nativeLib.func("httpcloak_set_cookie", "void", ["int64", "str", "str"]),
+      httpcloak_free_string: nativeLib.func("httpcloak_free_string", "void", ["str"]),
+      httpcloak_version: nativeLib.func("httpcloak_version", "str", []),
+      httpcloak_available_presets: nativeLib.func("httpcloak_available_presets", "str", []),
+    };
+  }
+  return lib;
+}
+
+/**
+ * Parse response from the native library
+ */
+function parseResponse(result) {
+  if (!result) {
+    throw new HTTPCloakError("No response received");
+  }
+
+  const data = JSON.parse(result);
+
+  if (data.error) {
+    throw new HTTPCloakError(data.error);
+  }
+
+  return new Response(data);
+}
+
+/**
+ * Get the httpcloak library version
+ */
+function version() {
+  const nativeLib = getLib();
+  return nativeLib.httpcloak_version() || "unknown";
+}
+
+/**
+ * Get list of available browser presets
+ */
+function availablePresets() {
+  const nativeLib = getLib();
+  const result = nativeLib.httpcloak_available_presets();
+  if (result) {
+    return JSON.parse(result);
+  }
+  return [];
+}
+
+/**
+ * HTTP Session with browser fingerprint emulation
+ */
+class Session {
+  /**
+   * Create a new session
+   * @param {Object} options - Session options
+   * @param {string} [options.preset="chrome-143"] - Browser preset to use
+   * @param {string} [options.proxy] - Proxy URL (e.g., "http://user:pass@host:port")
+   * @param {number} [options.timeout=30] - Request timeout in seconds
+   */
+  constructor(options = {}) {
+    const { preset = "chrome-143", proxy = null, timeout = 30 } = options;
+
+    this._lib = getLib();
+
+    const config = {
+      preset,
+      timeout,
+    };
+    if (proxy) {
+      config.proxy = proxy;
+    }
+
+    this._handle = this._lib.httpcloak_session_new(JSON.stringify(config));
+
+    if (this._handle === 0n || this._handle === 0) {
+      throw new HTTPCloakError("Failed to create session");
+    }
+  }
+
+  /**
+   * Close the session and release resources
+   */
+  close() {
+    if (this._handle) {
+      this._lib.httpcloak_session_free(this._handle);
+      this._handle = 0n;
+    }
+  }
+
+  // ===========================================================================
+  // Synchronous Methods
+  // ===========================================================================
+
+  /**
+   * Perform a synchronous GET request
+   * @param {string} url - Request URL
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Response} Response object
+   */
+  getSync(url, headers = null) {
+    const headersJson = headers ? JSON.stringify(headers) : null;
+    const result = this._lib.httpcloak_get(this._handle, url, headersJson);
+    return parseResponse(result);
+  }
+
+  /**
+   * Perform a synchronous POST request
+   * @param {string} url - Request URL
+   * @param {string|Buffer|Object} [body] - Request body
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Response} Response object
+   */
+  postSync(url, body = null, headers = null) {
+    if (typeof body === "object" && body !== null && !Buffer.isBuffer(body)) {
+      body = JSON.stringify(body);
+      headers = headers || {};
+      if (!headers["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+
+    if (Buffer.isBuffer(body)) {
+      body = body.toString("utf8");
+    }
+
+    const headersJson = headers ? JSON.stringify(headers) : null;
+    const result = this._lib.httpcloak_post(this._handle, url, body, headersJson);
+    return parseResponse(result);
+  }
+
+  /**
+   * Perform a synchronous custom HTTP request
+   * @param {Object} options - Request options
+   * @param {string} options.method - HTTP method
+   * @param {string} options.url - Request URL
+   * @param {Object} [options.headers] - Optional custom headers
+   * @param {string|Buffer|Object} [options.body] - Optional request body
+   * @param {number} [options.timeout] - Optional request timeout
+   * @returns {Response} Response object
+   */
+  requestSync(options) {
+    let { method, url, headers = null, body = null, timeout = null } = options;
+
+    if (typeof body === "object" && body !== null && !Buffer.isBuffer(body)) {
+      body = JSON.stringify(body);
+      headers = headers || {};
+      if (!headers["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+
+    if (Buffer.isBuffer(body)) {
+      body = body.toString("utf8");
+    }
+
+    const requestConfig = {
+      method: method.toUpperCase(),
+      url,
+    };
+    if (headers) requestConfig.headers = headers;
+    if (body) requestConfig.body = body;
+    if (timeout) requestConfig.timeout = timeout;
+
+    const result = this._lib.httpcloak_request(
+      this._handle,
+      JSON.stringify(requestConfig)
+    );
+    return parseResponse(result);
+  }
+
+  // ===========================================================================
+  // Promise-based Methods
+  // ===========================================================================
+
+  /**
+   * Perform an async GET request
+   * @param {string} url - Request URL
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  get(url, headers = null) {
+    return new Promise((resolve, reject) => {
+      setImmediate(() => {
+        try {
+          resolve(this.getSync(url, headers));
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Perform an async POST request
+   * @param {string} url - Request URL
+   * @param {string|Buffer|Object} [body] - Request body
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  post(url, body = null, headers = null) {
+    return new Promise((resolve, reject) => {
+      setImmediate(() => {
+        try {
+          resolve(this.postSync(url, body, headers));
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Perform an async custom HTTP request
+   * @param {Object} options - Request options
+   * @returns {Promise<Response>} Response object
+   */
+  request(options) {
+    return new Promise((resolve, reject) => {
+      setImmediate(() => {
+        try {
+          resolve(this.requestSync(options));
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Perform an async PUT request
+   * @param {string} url - Request URL
+   * @param {string|Buffer|Object} [body] - Request body
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  put(url, body = null, headers = null) {
+    return this.request({ method: "PUT", url, body, headers });
+  }
+
+  /**
+   * Perform an async DELETE request
+   * @param {string} url - Request URL
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  delete(url, headers = null) {
+    return this.request({ method: "DELETE", url, headers });
+  }
+
+  /**
+   * Perform an async PATCH request
+   * @param {string} url - Request URL
+   * @param {string|Buffer|Object} [body] - Request body
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  patch(url, body = null, headers = null) {
+    return this.request({ method: "PATCH", url, body, headers });
+  }
+
+  /**
+   * Perform an async HEAD request
+   * @param {string} url - Request URL
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  head(url, headers = null) {
+    return this.request({ method: "HEAD", url, headers });
+  }
+
+  /**
+   * Perform an async OPTIONS request
+   * @param {string} url - Request URL
+   * @param {Object} [headers] - Optional custom headers
+   * @returns {Promise<Response>} Response object
+   */
+  options(url, headers = null) {
+    return this.request({ method: "OPTIONS", url, headers });
+  }
+
+  // ===========================================================================
+  // Callback-based Methods
+  // ===========================================================================
+
+  /**
+   * Perform a GET request with callback
+   * @param {string} url - Request URL
+   * @param {Object|Function} [headersOrCallback] - Headers or callback
+   * @param {Function} [callback] - Callback function (err, response)
+   */
+  getCb(url, headersOrCallback, callback) {
+    let headers = null;
+    let cb = callback;
+
+    if (typeof headersOrCallback === "function") {
+      cb = headersOrCallback;
+    } else {
+      headers = headersOrCallback;
+    }
+
+    setImmediate(() => {
+      try {
+        const response = this.getSync(url, headers);
+        cb(null, response);
+      } catch (err) {
+        cb(err, null);
+      }
+    });
+  }
+
+  /**
+   * Perform a POST request with callback
+   * @param {string} url - Request URL
+   * @param {string|Buffer|Object} [body] - Request body
+   * @param {Object|Function} [headersOrCallback] - Headers or callback
+   * @param {Function} [callback] - Callback function (err, response)
+   */
+  postCb(url, body, headersOrCallback, callback) {
+    let headers = null;
+    let cb = callback;
+
+    if (typeof headersOrCallback === "function") {
+      cb = headersOrCallback;
+    } else {
+      headers = headersOrCallback;
+      cb = callback;
+    }
+
+    if (typeof body === "function") {
+      cb = body;
+      body = null;
+    }
+
+    setImmediate(() => {
+      try {
+        const response = this.postSync(url, body, headers);
+        cb(null, response);
+      } catch (err) {
+        cb(err, null);
+      }
+    });
+  }
+
+  /**
+   * Perform a custom request with callback
+   * @param {Object} options - Request options
+   * @param {Function} callback - Callback function (err, response)
+   */
+  requestCb(options, callback) {
+    setImmediate(() => {
+      try {
+        const response = this.requestSync(options);
+        callback(null, response);
+      } catch (err) {
+        callback(err, null);
+      }
+    });
+  }
+
+  // ===========================================================================
+  // Cookie Management
+  // ===========================================================================
+
+  /**
+   * Get all cookies from the session
+   * @returns {Object} Cookies as key-value pairs
+   */
+  getCookies() {
+    const result = this._lib.httpcloak_get_cookies(this._handle);
+    if (result) {
+      return JSON.parse(result);
+    }
+    return {};
+  }
+
+  /**
+   * Set a cookie in the session
+   * @param {string} name - Cookie name
+   * @param {string} value - Cookie value
+   */
+  setCookie(name, value) {
+    this._lib.httpcloak_set_cookie(this._handle, name, value);
+  }
+
+  /**
+   * Get cookies as a property
+   */
+  get cookies() {
+    return this.getCookies();
+  }
+}
+
+module.exports = {
+  Session,
+  Response,
+  HTTPCloakError,
+  version,
+  availablePresets,
+};

package/npm/darwin-arm64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-darwin-arm64.dylib");

package/npm/darwin-arm64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/darwin-arm64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for darwin arm64",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/npm/darwin-x64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-darwin-amd64.dylib");

package/npm/darwin-x64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/darwin-x64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for darwin x64",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/npm/linux-arm64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-linux-arm64.so");

package/npm/linux-arm64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/linux-arm64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for linux arm64",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/npm/linux-x64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-linux-amd64.so");

package/npm/linux-x64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/linux-x64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for linux x64",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/npm/win32-arm64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-windows-arm64.dll");

package/npm/win32-arm64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/win32-arm64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for win32 arm64",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/npm/win32-x64/lib.js

@@ -0,0 +1,3 @@
+// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "libhttpcloak-windows-amd64.dll");

package/npm/win32-x64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@httpcloak/win32-x64",
+  "version": "1.0.0",
+  "description": "HTTPCloak native binary for win32 x64",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "lib.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "httpcloak",
+  "version": "1.0.0",
+  "description": "Browser fingerprint emulation HTTP client with HTTP/1.1, HTTP/2, and HTTP/3 support",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "node test.js",
+    "setup-packages": "node scripts/setup-npm-packages.js"
+  },
+  "keywords": [
+    "http",
+    "http2",
+    "http3",
+    "quic",
+    "tls",
+    "fingerprint",
+    "browser",
+    "scraping",
+    "bot-detection"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sardanioss/httpcloak"
+  },
+  "bugs": {
+    "url": "https://github.com/sardanioss/httpcloak/issues"
+  },
+  "homepage": "https://github.com/sardanioss/httpcloak#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "koffi": "^2.9.0"
+  },
+  "optionalDependencies": {
+    "@httpcloak/linux-x64": "1.0.0",
+    "@httpcloak/linux-arm64": "1.0.0",
+    "@httpcloak/darwin-x64": "1.0.0",
+    "@httpcloak/darwin-arm64": "1.0.0",
+    "@httpcloak/win32-x64": "1.0.0",
+    "@httpcloak/win32-arm64": "1.0.0"
+  }
+}

package/scripts/setup-npm-packages.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Generate platform-specific npm packages for httpcloak
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const VERSION = "1.4.0";
+
+const PLATFORMS = [
+  { name: "linux-x64", os: "linux", cpu: "x64", libName: "libhttpcloak-linux-amd64.so" },
+  { name: "linux-arm64", os: "linux", cpu: "arm64", libName: "libhttpcloak-linux-arm64.so" },
+  { name: "darwin-x64", os: "darwin", cpu: "x64", libName: "libhttpcloak-darwin-amd64.dylib" },
+  { name: "darwin-arm64", os: "darwin", cpu: "arm64", libName: "libhttpcloak-darwin-arm64.dylib" },
+  { name: "win32-x64", os: "win32", cpu: "x64", libName: "libhttpcloak-windows-amd64.dll" },
+  { name: "win32-arm64", os: "win32", cpu: "arm64", libName: "libhttpcloak-windows-arm64.dll" },
+];
+
+const npmDir = path.join(__dirname, "..", "npm");
+
+// Create each platform package
+for (const platform of PLATFORMS) {
+  const pkgDir = path.join(npmDir, platform.name);
+
+  // Create directory
+  fs.mkdirSync(pkgDir, { recursive: true });
+
+  // Create package.json
+  const packageJson = {
+    name: `@httpcloak/${platform.name}`,
+    version: VERSION,
+    description: `HTTPCloak native binary for ${platform.os} ${platform.cpu}`,
+    os: [platform.os],
+    cpu: [platform.cpu],
+    main: "lib.js",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "https://github.com/sardanioss/httpcloak",
+    },
+    publishConfig: {
+      access: "public",
+    },
+  };
+
+  fs.writeFileSync(
+    path.join(pkgDir, "package.json"),
+    JSON.stringify(packageJson, null, 2) + "\n"
+  );
+
+  // Create lib.js that exports the library path
+  const libJs = `// Auto-generated - exports path to native library
+const path = require("path");
+module.exports = path.join(__dirname, "${platform.libName}");
+`;
+  fs.writeFileSync(path.join(pkgDir, "lib.js"), libJs);
+
+  console.log(`Created: @httpcloak/${platform.name}`);
+}
+
+// Create optionalDependencies for main package
+const optionalDeps = {};
+for (const platform of PLATFORMS) {
+  optionalDeps[`@httpcloak/${platform.name}`] = VERSION;
+}
+
+console.log("\nAdd to main package.json optionalDependencies:");
+console.log(JSON.stringify(optionalDeps, null, 2));

package/test.js

@@ -0,0 +1,87 @@
+/**
+ * HTTPCloak Node.js Test
+ */
+
+const { Session, version, availablePresets, HTTPCloakError } = require("./lib");
+
+async function main() {
+  console.log("=== HTTPCloak Node.js Test ===\n");
+
+  // Test version
+  console.log("Version:", version());
+
+  // Test presets
+  const presets = availablePresets();
+  console.log("Presets:", presets.slice(0, 5).join(", "), "...");
+  console.log("");
+
+  // Create session
+  const session = new Session({ preset: "chrome-143" });
+
+  try {
+    // Test sync GET
+    console.log("--- Sync GET ---");
+    const syncResponse = session.getSync(
+      "https://www.cloudflare.com/cdn-cgi/trace"
+    );
+    console.log("Status:", syncResponse.statusCode);
+    console.log("Protocol:", syncResponse.protocol);
+    console.log("");
+
+    // Test async GET
+    console.log("--- Async GET (Promise) ---");
+    const asyncResponse = await session.get(
+      "https://www.cloudflare.com/cdn-cgi/trace"
+    );
+    console.log("Status:", asyncResponse.statusCode);
+    console.log("Protocol:", asyncResponse.protocol);
+    console.log("");
+
+    // Test callback GET
+    console.log("--- Callback GET ---");
+    await new Promise((resolve, reject) => {
+      session.getCb(
+        "https://www.cloudflare.com/cdn-cgi/trace",
+        (err, response) => {
+          if (err) {
+            console.error("Error:", err.message);
+            reject(err);
+            return;
+          }
+          console.log("Status:", response.statusCode);
+          console.log("Protocol:", response.protocol);
+          resolve();
+        }
+      );
+    });
+    console.log("");
+
+    // Test concurrent requests
+    console.log("--- Concurrent Requests ---");
+    const startTime = Date.now();
+    const responses = await Promise.all([
+      session.get("https://www.cloudflare.com/cdn-cgi/trace"),
+      session.get("https://www.cloudflare.com/cdn-cgi/trace"),
+    ]);
+    const elapsed = Date.now() - startTime;
+    console.log("Concurrent requests:", responses.length);
+    console.log("Time:", elapsed, "ms");
+    console.log("");
+
+    // Test cookies
+    console.log("--- Cookies ---");
+    session.setCookie("test_cookie", "test_value");
+    const cookies = session.getCookies();
+    console.log("Cookies:", JSON.stringify(cookies));
+    console.log("");
+
+    console.log("=== All tests passed! ===");
+  } catch (err) {
+    console.error("Test failed:", err);
+    process.exit(1);
+  } finally {
+    session.close();
+  }
+}
+
+main();