jiren 1.3.1 → 1.4.0

package/dist/index.js

@@ -1,712 +0,0 @@
-// @bun
-var __require = import.meta.require;
-
-// components/client.ts
-import { toArrayBuffer } from "bun:ffi";
-
-// components/native.ts
-import { dlopen, FFIType, suffix } from "bun:ffi";
-import { join } from "path";
-var libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
-var ffiDef = {
-  zclient_new: {
-    args: [],
-    returns: FFIType.ptr
-  },
-  zclient_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_get: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_post: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_request: {
-    args: [
-      FFIType.ptr,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.u8,
-      FFIType.bool
-    ],
-    returns: FFIType.ptr
-  },
-  zclient_prefetch: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.void
-  },
-  zclient_response_status: {
-    args: [FFIType.ptr],
-    returns: FFIType.u16
-  },
-  zclient_response_body: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_body_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_headers: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_headers_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_parse_header_offsets: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_header_offsets_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  z_find_header_value: {
-    args: [FFIType.ptr, FFIType.u64, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_header_value_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_response_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_set_benchmark_mode: {
-    args: [FFIType.ptr, FFIType.bool],
-    returns: FFIType.void
-  }
-};
-var lib = dlopen(libPath, ffiDef);
-
-// components/cache.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { gzipSync, gunzipSync } from "zlib";
-import { createHash } from "crypto";
-import { join as join2 } from "path";
-
-class ResponseCache {
-  cacheDir;
-  maxSize;
-  constructor(maxSize = 100, cacheDir = ".cache/jiren") {
-    this.maxSize = maxSize;
-    this.cacheDir = cacheDir;
-    if (!existsSync(this.cacheDir)) {
-      mkdirSync(this.cacheDir, { recursive: true });
-    }
-  }
-  generateKey(url, path, options) {
-    const fullUrl = path ? `${url}${path}` : url;
-    const method = options?.method || "GET";
-    const headers = JSON.stringify(options?.headers || {});
-    const key = `${method}:${fullUrl}:${headers}`;
-    return createHash("md5").update(key).digest("hex");
-  }
-  getCacheFilePath(key) {
-    return join2(this.cacheDir, `${key}.json.gz`);
-  }
-  get(url, path, options) {
-    const key = this.generateKey(url, path, options);
-    const filePath = this.getCacheFilePath(key);
-    if (!existsSync(filePath))
-      return null;
-    try {
-      const compressed = readFileSync(filePath);
-      const decompressed = gunzipSync(compressed);
-      const data = decompressed.toString("utf-8");
-      const entry = JSON.parse(data);
-      const now = Date.now();
-      if (now - entry.timestamp > entry.ttl) {
-        try {
-          __require("fs").unlinkSync(filePath);
-        } catch {}
-        return null;
-      }
-      return entry.response;
-    } catch (error) {
-      try {
-        __require("fs").unlinkSync(filePath);
-      } catch {}
-      return null;
-    }
-  }
-  set(url, response, ttl, path, options) {
-    const key = this.generateKey(url, path, options);
-    const filePath = this.getCacheFilePath(key);
-    const entry = {
-      response,
-      timestamp: Date.now(),
-      ttl
-    };
-    try {
-      const json = JSON.stringify(entry);
-      const compressed = gzipSync(json);
-      writeFileSync(filePath, compressed);
-    } catch (error) {
-      console.warn("Failed to write cache:", error);
-    }
-  }
-  clear(url) {
-    if (url) {
-      this.clearAll();
-    } else {
-      this.clearAll();
-    }
-  }
-  clearAll() {
-    try {
-      const fs = __require("fs");
-      const files = fs.readdirSync(this.cacheDir);
-      for (const file of files) {
-        if (file.endsWith(".json.gz")) {
-          fs.unlinkSync(join2(this.cacheDir, file));
-        }
-      }
-    } catch (error) {}
-  }
-  stats() {
-    try {
-      const fs = __require("fs");
-      const files = fs.readdirSync(this.cacheDir);
-      const cacheFiles = files.filter((f) => f.endsWith(".json.gz"));
-      let totalSize = 0;
-      for (const file of cacheFiles) {
-        const stats = fs.statSync(join2(this.cacheDir, file));
-        totalSize += stats.size;
-      }
-      return {
-        size: cacheFiles.length,
-        maxSize: this.maxSize,
-        cacheDir: this.cacheDir,
-        totalSizeKB: (totalSize / 1024).toFixed(2)
-      };
-    } catch {
-      return {
-        size: 0,
-        maxSize: this.maxSize,
-        cacheDir: this.cacheDir,
-        totalSizeKB: "0"
-      };
-    }
-  }
-}
-
-// components/client.ts
-var STATUS_TEXT = {
-  200: "OK",
-  201: "Created",
-  204: "No Content",
-  301: "Moved Permanently",
-  302: "Found",
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  500: "Internal Server Error",
-  502: "Bad Gateway",
-  503: "Service Unavailable"
-};
-class JirenClient {
-  ptr;
-  urlMap = new Map;
-  cacheConfig = new Map;
-  cache;
-  inflightRequests = new Map;
-  globalRetry;
-  url;
-  constructor(options) {
-    this.ptr = lib.symbols.zclient_new();
-    if (!this.ptr)
-      throw new Error("Failed to create native client instance");
-    this.cache = new ResponseCache(100);
-    if (options?.benchmark) {
-      lib.symbols.zclient_set_benchmark_mode(this.ptr, true);
-    }
-    if (options?.warmup) {
-      const urls = [];
-      const warmup = options.warmup;
-      if (Array.isArray(warmup)) {
-        for (const item of warmup) {
-          if (typeof item === "string") {
-            urls.push(item);
-          } else {
-            const config = item;
-            urls.push(config.url);
-            this.urlMap.set(config.key, config.url);
-            if (config.cache) {
-              const cacheConfig = typeof config.cache === "boolean" ? { enabled: true, ttl: 60000 } : { enabled: true, ttl: config.cache.ttl || 60000 };
-              this.cacheConfig.set(config.key, cacheConfig);
-            }
-          }
-        }
-      } else {
-        for (const [key, urlConfig] of Object.entries(warmup)) {
-          if (typeof urlConfig === "string") {
-            urls.push(urlConfig);
-            this.urlMap.set(key, urlConfig);
-          } else {
-            urls.push(urlConfig.url);
-            this.urlMap.set(key, urlConfig.url);
-            if (urlConfig.cache) {
-              const cacheConfig = typeof urlConfig.cache === "boolean" ? { enabled: true, ttl: 60000 } : { enabled: true, ttl: urlConfig.cache.ttl || 60000 };
-              this.cacheConfig.set(key, cacheConfig);
-            }
-          }
-        }
-      }
-      if (urls.length > 0) {
-        this.warmup(urls);
-      }
-    }
-    this.url = this.createUrlAccessor();
-    if (options?.retry) {
-      this.globalRetry = typeof options.retry === "number" ? { count: options.retry, delay: 100, backoff: 2 } : options.retry;
-    }
-  }
-  async waitFor(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  createUrlAccessor() {
-    const self = this;
-    return new Proxy({}, {
-      get(_target, prop) {
-        const baseUrl = self.urlMap.get(prop);
-        if (!baseUrl) {
-          throw new Error(`URL key "${prop}" not found. Available keys: ${Array.from(self.urlMap.keys()).join(", ")}`);
-        }
-        const buildUrl = (path) => path ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}` : baseUrl;
-        return {
-          get: async (options) => {
-            const cacheConfig = self.cacheConfig.get(prop);
-            if (cacheConfig?.enabled) {
-              const cached = self.cache.get(baseUrl, options?.path, options);
-              if (cached) {
-                return self.rehydrateResponse(cached);
-              }
-            }
-            const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(options?.headers || {})}`;
-            if (self.inflightRequests.has(dedupKey)) {
-              return self.inflightRequests.get(dedupKey);
-            }
-            const requestPromise = (async () => {
-              try {
-                const response = await self.request("GET", buildUrl(options?.path), null, {
-                  headers: options?.headers,
-                  maxRedirects: options?.maxRedirects,
-                  responseType: options?.responseType,
-                  antibot: options?.antibot
-                });
-                if (cacheConfig?.enabled && typeof response === "object" && "status" in response) {
-                  self.cache.set(baseUrl, response, cacheConfig.ttl, options?.path, options);
-                }
-                return response;
-              } finally {
-                self.inflightRequests.delete(dedupKey);
-              }
-            })();
-            self.inflightRequests.set(dedupKey, requestPromise);
-            return requestPromise;
-          },
-          post: async (options) => {
-            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
-            return self.request("POST", buildUrl(options?.path), serializedBody, {
-              headers,
-              maxRedirects: options?.maxRedirects,
-              responseType: options?.responseType
-            });
-          },
-          put: async (options) => {
-            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
-            return self.request("PUT", buildUrl(options?.path), serializedBody, {
-              headers,
-              maxRedirects: options?.maxRedirects,
-              responseType: options?.responseType
-            });
-          },
-          patch: async (options) => {
-            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
-            return self.request("PATCH", buildUrl(options?.path), serializedBody, {
-              headers,
-              maxRedirects: options?.maxRedirects,
-              responseType: options?.responseType
-            });
-          },
-          delete: async (options) => {
-            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
-            return self.request("DELETE", buildUrl(options?.path), serializedBody, {
-              headers,
-              maxRedirects: options?.maxRedirects,
-              responseType: options?.responseType
-            });
-          },
-          head: async (options) => {
-            return self.request("HEAD", buildUrl(options?.path), null, {
-              headers: options?.headers,
-              maxRedirects: options?.maxRedirects,
-              antibot: options?.antibot
-            });
-          },
-          options: async (options) => {
-            return self.request("OPTIONS", buildUrl(options?.path), null, {
-              headers: options?.headers,
-              maxRedirects: options?.maxRedirects,
-              antibot: options?.antibot
-            });
-          },
-          prefetch: async (options) => {
-            self.cache.clear(baseUrl);
-            const cacheConfig = self.cacheConfig.get(prop);
-            if (cacheConfig?.enabled) {
-              await self.request("GET", buildUrl(options?.path), null, {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                antibot: options?.antibot
-              });
-            }
-          }
-        };
-      }
-    });
-  }
-  close() {
-    if (this.ptr) {
-      lib.symbols.zclient_free(this.ptr);
-      this.ptr = null;
-    }
-  }
-  async warmup(urls) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    await Promise.all(urls.map((url) => new Promise((resolve) => {
-      const urlBuffer = Buffer.from(url + "\x00");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
-      resolve();
-    })));
-  }
-  prefetch(urls) {
-    this.warmup(urls);
-  }
-  async request(method, url, body, options) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    let headers = {};
-    let maxRedirects = 5;
-    let responseType;
-    let antibot = false;
-    if (options) {
-      if ("maxRedirects" in options || "headers" in options || "responseType" in options || "method" in options || "timeout" in options || "antibot" in options) {
-        const opts = options;
-        if (opts.headers)
-          headers = opts.headers;
-        if (opts.maxRedirects !== undefined)
-          maxRedirects = opts.maxRedirects;
-        if (opts.responseType)
-          responseType = opts.responseType;
-        if (opts.antibot !== undefined)
-          antibot = opts.antibot;
-      } else {
-        headers = options;
-      }
-    }
-    const methodBuffer = Buffer.from(method + "\x00");
-    const urlBuffer = Buffer.from(url + "\x00");
-    let bodyBuffer = null;
-    if (body) {
-      bodyBuffer = Buffer.from(body + "\x00");
-    }
-    let headersBuffer = null;
-    const defaultHeaders = {
-      "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
-      "accept-encoding": "gzip",
-      "accept-language": "en-US,en;q=0.9",
-      "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
-      "sec-ch-ua-mobile": "?0",
-      "sec-ch-ua-platform": '"macOS"',
-      "sec-fetch-dest": "document",
-      "sec-fetch-mode": "navigate",
-      "sec-fetch-site": "none",
-      "sec-fetch-user": "?1",
-      "upgrade-insecure-requests": "1"
-    };
-    const finalHeaders = { ...defaultHeaders, ...headers };
-    const orderedHeaders = {};
-    const keys = [
-      "sec-ch-ua",
-      "sec-ch-ua-mobile",
-      "sec-ch-ua-platform",
-      "upgrade-insecure-requests",
-      "user-agent",
-      "accept",
-      "sec-fetch-site",
-      "sec-fetch-mode",
-      "sec-fetch-user",
-      "sec-fetch-dest",
-      "accept-encoding",
-      "accept-language"
-    ];
-    for (const key of keys) {
-      if (finalHeaders[key]) {
-        orderedHeaders[key] = finalHeaders[key];
-        delete finalHeaders[key];
-      }
-    }
-    for (const [key, value] of Object.entries(finalHeaders)) {
-      orderedHeaders[key] = value;
-    }
-    const headerStr = Object.entries(orderedHeaders).map(([k, v]) => `${k.toLowerCase()}: ${v}`).join(`\r
-`);
-    if (headerStr.length > 0) {
-      headersBuffer = Buffer.from(headerStr + "\x00");
-    }
-    let retryConfig = this.globalRetry;
-    if (options && typeof options === "object" && "retry" in options) {
-      const userRetry = options.retry;
-      if (typeof userRetry === "number") {
-        retryConfig = { count: userRetry, delay: 100, backoff: 2 };
-      } else if (typeof userRetry === "object") {
-        retryConfig = userRetry;
-      }
-    }
-    let attempts = 0;
-    const maxAttempts = (retryConfig?.count || 0) + 1;
-    let currentDelay = retryConfig?.delay || 100;
-    const backoff = retryConfig?.backoff || 2;
-    let lastError;
-    while (attempts < maxAttempts) {
-      attempts++;
-      try {
-        const respPtr = lib.symbols.zclient_request(this.ptr, methodBuffer, urlBuffer, headersBuffer, bodyBuffer, maxRedirects, antibot);
-        if (!respPtr) {
-          throw new Error("Native request failed (returned null pointer)");
-        }
-        const response = this.parseResponse(respPtr, url);
-        if (responseType) {
-          if (responseType === "json")
-            return response.body.json();
-          if (responseType === "text")
-            return response.body.text();
-          if (responseType === "arraybuffer")
-            return response.body.arrayBuffer();
-          if (responseType === "blob")
-            return response.body.blob();
-        }
-        return response;
-      } catch (err) {
-        lastError = err;
-        if (attempts < maxAttempts) {
-          await this.waitFor(currentDelay);
-          currentDelay *= backoff;
-        }
-      }
-    }
-    throw lastError || new Error("Request failed after retries");
-  }
-  parseResponse(respPtr, url) {
-    if (!respPtr)
-      throw new Error("Native request failed (returned null pointer)");
-    try {
-      const status = lib.symbols.zclient_response_status(respPtr);
-      const len = Number(lib.symbols.zclient_response_body_len(respPtr));
-      const bodyPtr = lib.symbols.zclient_response_body(respPtr);
-      const headersLen = Number(lib.symbols.zclient_response_headers_len(respPtr));
-      let headersObj = {};
-      if (headersLen > 0) {
-        const rawHeadersPtr = lib.symbols.zclient_response_headers(respPtr);
-        if (rawHeadersPtr) {
-          const rawSrc = toArrayBuffer(rawHeadersPtr, 0, headersLen);
-          const raw = new Uint8Array(rawSrc.slice(0));
-          headersObj = new NativeHeaders(raw);
-        }
-      }
-      const headersProxy = new Proxy(headersObj instanceof NativeHeaders ? headersObj : {}, {
-        get(target, prop) {
-          if (target instanceof NativeHeaders && typeof prop === "string") {
-            if (prop === "toJSON")
-              return () => target.toJSON();
-            const val = target.get(prop);
-            if (val !== null)
-              return val;
-          }
-          return Reflect.get(target, prop);
-        }
-      });
-      let buffer = new ArrayBuffer(0);
-      if (len > 0 && bodyPtr) {
-        buffer = toArrayBuffer(bodyPtr, 0, len).slice(0);
-      }
-      let base64Data = "";
-      try {
-        base64Data = Buffer.from(buffer).toString("base64");
-      } catch (e) {}
-      let bodyUsed = false;
-      const consumeBody = () => {
-        if (bodyUsed) {}
-        bodyUsed = true;
-      };
-      const bodyObj = {
-        bodyUsed: false,
-        _raw: base64Data,
-        arrayBuffer: async () => {
-          consumeBody();
-          if (Buffer.isBuffer(buffer)) {
-            const buf = buffer;
-            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-          }
-          return buffer;
-        },
-        blob: async () => {
-          consumeBody();
-          return new Blob([buffer]);
-        },
-        text: async () => {
-          consumeBody();
-          return new TextDecoder().decode(buffer);
-        },
-        json: async () => {
-          consumeBody();
-          const text = new TextDecoder().decode(buffer);
-          return JSON.parse(text);
-        }
-      };
-      Object.defineProperty(bodyObj, "bodyUsed", {
-        get: () => bodyUsed
-      });
-      return {
-        url,
-        status,
-        statusText: STATUS_TEXT[status] || "",
-        headers: headersProxy,
-        ok: status >= 200 && status < 300,
-        redirected: false,
-        type: "basic",
-        body: bodyObj
-      };
-    } finally {
-      lib.symbols.zclient_response_free(respPtr);
-    }
-  }
-  prepareBody(body, userHeaders) {
-    let serializedBody = null;
-    const headers = { ...userHeaders };
-    if (body !== null && body !== undefined) {
-      if (typeof body === "object") {
-        serializedBody = JSON.stringify(body);
-        const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
-        if (!hasContentType) {
-          headers["Content-Type"] = "application/json";
-        }
-      } else {
-        serializedBody = String(body);
-      }
-    }
-    return { headers, serializedBody };
-  }
-  rehydrateResponse(cached) {
-    if (typeof cached.body.text === "function")
-      return cached;
-    const rawData = cached.body._raw;
-    let buffer;
-    if (rawData) {
-      buffer = Buffer.from(rawData, "base64");
-    } else {
-      buffer = Buffer.from("");
-    }
-    let bodyUsed = cached.body.bodyUsed || false;
-    const consumeBody = () => {
-      bodyUsed = true;
-    };
-    const bodyObj = {
-      _raw: rawData,
-      bodyUsed,
-      arrayBuffer: async () => {
-        consumeBody();
-        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-      },
-      blob: async () => {
-        consumeBody();
-        return new Blob([buffer]);
-      },
-      text: async () => {
-        consumeBody();
-        return new TextDecoder().decode(buffer);
-      },
-      json: async () => {
-        consumeBody();
-        const text = new TextDecoder().decode(buffer);
-        return JSON.parse(text);
-      }
-    };
-    Object.defineProperty(bodyObj, "bodyUsed", {
-      get: () => bodyUsed
-    });
-    return {
-      ...cached,
-      body: bodyObj
-    };
-  }
-}
-
-class NativeHeaders {
-  raw;
-  len;
-  decoder = new TextDecoder;
-  cache = new Map;
-  constructor(raw) {
-    this.raw = raw;
-    this.len = raw.byteLength;
-  }
-  get(name) {
-    const target = name.toLowerCase();
-    if (this.cache.has(target))
-      return this.cache.get(target);
-    const keyBuf = Buffer.from(target + "\x00");
-    const resPtr = lib.symbols.z_find_header_value(this.raw, this.len, keyBuf);
-    if (!resPtr)
-      return null;
-    try {
-      const view = new DataView(toArrayBuffer(resPtr, 0, 16));
-      const valPtr = view.getBigUint64(0, true);
-      const valLen = Number(view.getBigUint64(8, true));
-      if (valLen === 0) {
-        this.cache.set(target, "");
-        return "";
-      }
-      const valBytes = toArrayBuffer(Number(valPtr), 0, valLen);
-      const val = this.decoder.decode(valBytes);
-      this.cache.set(target, val);
-      return val;
-    } finally {
-      lib.symbols.zclient_header_value_free(resPtr);
-    }
-  }
-  toJSON() {
-    const obj = {};
-    const text = this.decoder.decode(this.raw);
-    const lines = text.split(`\r
-`);
-    for (const line of lines) {
-      if (!line)
-        continue;
-      const colon = line.indexOf(":");
-      if (colon === -1)
-        continue;
-      const key = line.substring(0, colon).trim().toLowerCase();
-      const val = line.substring(colon + 1).trim();
-      obj[key] = val;
-    }
-    return obj;
-  }
-}
-export {
-  JirenClient
-};