jiren 1.2.6 → 1.2.8

package/dist/index-node.js

@@ -0,0 +1,569 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// components/native-node.ts
+import koffi from "koffi";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var platform = process.platform;
+var suffix = "so";
+if (platform === "darwin") {
+  suffix = "dylib";
+} else if (platform === "win32") {
+  suffix = "dll";
+}
+var libPath = path.join(__dirname2, `../lib/libhttpclient.${suffix}`);
+var lib = koffi.load(libPath);
+var symbols = {
+  zclient_new: lib.func("zclient_new", "void *", []),
+  zclient_free: lib.func("zclient_free", "void", ["void *"]),
+  zclient_get: lib.func("zclient_get", "void *", ["void *", "const char *"]),
+  zclient_post: lib.func("zclient_post", "void *", [
+    "void *",
+    "const char *",
+    "const char *"
+  ]),
+  zclient_request: lib.func("zclient_request", "void *", [
+    "void *",
+    "const char *",
+    "const char *",
+    "const char *",
+    "const char *",
+    "uint8_t",
+    "bool"
+  ]),
+  zclient_prefetch: lib.func("zclient_prefetch", "void", [
+    "void *",
+    "const char *"
+  ]),
+  zclient_response_status: lib.func("zclient_response_status", "uint16_t", [
+    "void *"
+  ]),
+  zclient_response_body: lib.func("zclient_response_body", "void *", [
+    "void *"
+  ]),
+  zclient_response_body_len: lib.func("zclient_response_body_len", "uint64_t", [
+    "void *"
+  ]),
+  zclient_response_headers: lib.func("zclient_response_headers", "void *", [
+    "void *"
+  ]),
+  zclient_response_headers_len: lib.func("zclient_response_headers_len", "uint64_t", ["void *"]),
+  zclient_response_parse_header_offsets: lib.func("zclient_response_parse_header_offsets", "void *", ["void *"]),
+  zclient_header_offsets_free: lib.func("zclient_header_offsets_free", "void", [
+    "void *"
+  ]),
+  z_find_header_value: lib.func("z_find_header_value", "void *", [
+    "void *",
+    "uint64_t",
+    "const char *"
+  ]),
+  zclient_header_value_free: lib.func("zclient_header_value_free", "void", [
+    "void *"
+  ]),
+  zclient_response_free: lib.func("zclient_response_free", "void", ["void *"]),
+  zclient_set_benchmark_mode: lib.func("zclient_set_benchmark_mode", "void", [
+    "void *",
+    "bool"
+  ])
+};
+var nativeLib = {
+  symbols
+};
+
+// components/cache.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { gzipSync, gunzipSync } from "zlib";
+import { createHash } from "crypto";
+import { join } 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, path2, options) {
+    const fullUrl = path2 ? `${url}${path2}` : 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 join(this.cacheDir, `${key}.json.gz`);
+  }
+  get(url, path2, options) {
+    const key = this.generateKey(url, path2, 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, path2, options) {
+    const key = this.generateKey(url, path2, 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(join(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(join(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-node-native.ts
+import koffi2 from "koffi";
+import zlib from "zlib";
+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 = null;
+  urlMap = new Map;
+  cacheConfig = new Map;
+  cache;
+  url;
+  constructor(options) {
+    this.ptr = nativeLib.symbols.zclient_new();
+    if (!this.ptr)
+      throw new Error("Failed to create native client instance");
+    this.cache = new ResponseCache(100);
+    if (options?.benchmark) {
+      nativeLib.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();
+  }
+  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 = (path2) => path2 ? `${baseUrl.replace(/\/$/, "")}/${path2.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 cached;
+              }
+            }
+            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;
+          },
+          post: async (body, options) => {
+            return self.request("POST", buildUrl(options?.path), body || null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          put: async (body, options) => {
+            return self.request("PUT", buildUrl(options?.path), body || null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          patch: async (body, options) => {
+            return self.request("PATCH", buildUrl(options?.path), body || null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          delete: async (body, options) => {
+            return self.request("DELETE", buildUrl(options?.path), body || null, {
+              headers: options?.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) {
+      nativeLib.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");
+      nativeLib.symbols.zclient_prefetch(this.ptr, url);
+      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 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
+`);
+    const respPtr = nativeLib.symbols.zclient_request(this.ptr, method, url, headerStr.length > 0 ? headerStr : null, body || null, maxRedirects, antibot);
+    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;
+  }
+  parseResponse(respPtr, url) {
+    if (!respPtr)
+      throw new Error("Native request failed (returned null pointer)");
+    try {
+      const status = nativeLib.symbols.zclient_response_status(respPtr);
+      const len = Number(nativeLib.symbols.zclient_response_body_len(respPtr));
+      const bodyPtr = nativeLib.symbols.zclient_response_body(respPtr);
+      const headersLen = Number(nativeLib.symbols.zclient_response_headers_len(respPtr));
+      let headersObj = {};
+      if (headersLen > 0) {
+        const rawHeadersPtr = nativeLib.symbols.zclient_response_headers(respPtr);
+        if (rawHeadersPtr) {
+          const raw = Buffer.from(koffi2.decode(rawHeadersPtr, "uint8_t", headersLen));
+          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 = Buffer.alloc(0);
+      if (len > 0 && bodyPtr) {
+        buffer = Buffer.from(koffi2.decode(bodyPtr, "uint8_t", len));
+        const contentEncoding = headersProxy["content-encoding"]?.toLowerCase();
+        if (len > 0) {
+          console.log(`[Jiren] Body len: ${len}, Encoding: ${contentEncoding}`);
+          if (buffer.length > 2) {
+            console.log(`[Jiren] Bytes: 0x${buffer[0]?.toString(16)} 0x${buffer[1]?.toString(16)} 0x${buffer[2]?.toString(16)}`);
+          }
+        }
+        if (contentEncoding === "gzip" || buffer.length > 2 && buffer[0] === 31 && buffer[1] === 139) {
+          try {
+            console.log("[Jiren] Attempting gunzip...");
+            buffer = zlib.gunzipSync(buffer);
+            console.log("[Jiren] Gunzip success!");
+          } catch (e) {
+            console.warn("Failed to gunzip response body:", e);
+          }
+        }
+      }
+      let bodyUsed = false;
+      const consumeBody = () => {
+        bodyUsed = true;
+      };
+      const bodyObj = {
+        bodyUsed: false,
+        arrayBuffer: async () => {
+          consumeBody();
+          return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        },
+        blob: async () => {
+          consumeBody();
+          return new Blob([buffer]);
+        },
+        text: async () => {
+          consumeBody();
+          return buffer.toString("utf-8");
+        },
+        json: async () => {
+          consumeBody();
+          return JSON.parse(buffer.toString("utf-8"));
+        }
+      };
+      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 {
+      nativeLib.symbols.zclient_response_free(respPtr);
+    }
+  }
+}
+
+class NativeHeaders {
+  raw;
+  len;
+  cache = new Map;
+  parsed = false;
+  constructor(raw) {
+    this.raw = raw;
+    this.len = raw.length;
+  }
+  ensureParsed() {
+    if (this.parsed)
+      return;
+    try {
+      const text = this.raw.toString("utf-8");
+      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();
+        this.cache.set(key, val);
+      }
+    } catch (e) {}
+    this.parsed = true;
+  }
+  get(name) {
+    const target = name.toLowerCase();
+    this.ensureParsed();
+    return this.cache.get(target) || null;
+  }
+  toJSON() {
+    this.ensureParsed();
+    return Object.fromEntries(this.cache);
+  }
+}
+export {
+  JirenClient
+};