rezo 1.0.42 → 1.0.44

package/dist/utils/curl.js

@@ -0,0 +1,314 @@
+import { RezoFormData } from './form-data.js';
+export function toCurl(config) {
+  const parts = ["curl"];
+  const method = (config.method || "GET").toUpperCase();
+  if (method !== "GET") {
+    parts.push("-X", method);
+  }
+  const headers = config.headers || {};
+  const normalizedHeaders = {};
+  if (headers && typeof headers === "object") {
+    const headersAny = headers;
+    if (typeof headersAny.entries === "function") {
+      for (const [key, value] of headersAny.entries()) {
+        normalizedHeaders[key.toLowerCase()] = value;
+      }
+    } else if (typeof headersAny.forEach === "function") {
+      headersAny.forEach((value, key) => {
+        normalizedHeaders[key.toLowerCase()] = value;
+      });
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined && value !== null) {
+          normalizedHeaders[key.toLowerCase()] = String(value);
+        }
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(normalizedHeaders)) {
+    parts.push("-H", escapeShellArg(`${key}: ${value}`));
+  }
+  const body = config.body ?? config.data;
+  if (body !== undefined && body !== null) {
+    let dataString;
+    if (typeof body === "string") {
+      dataString = body;
+    } else if (body instanceof RezoFormData) {
+      const entries = [];
+      const formData = body.toNativeFormData();
+      formData.forEach((value, key) => {
+        entries.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+      });
+      dataString = entries.join("&");
+      parts.push("--data-urlencode", escapeShellArg(dataString));
+    } else if (typeof body === "object") {
+      const contentType = normalizedHeaders["content-type"] || "";
+      if (contentType.includes("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams;
+        for (const [key, value] of Object.entries(body)) {
+          params.append(key, String(value));
+        }
+        dataString = params.toString();
+      } else {
+        dataString = JSON.stringify(body);
+        if (!normalizedHeaders["content-type"]) {
+          parts.push("-H", escapeShellArg("content-type: application/json"));
+        }
+      }
+    } else {
+      dataString = String(body);
+    }
+    if (!(body instanceof RezoFormData)) {
+      if (method === "GET" || method === "HEAD") {
+        parts.push("-G", "--data-raw", escapeShellArg(dataString));
+      } else {
+        parts.push("--data-raw", escapeShellArg(dataString));
+      }
+    }
+  }
+  if (config.timeout) {
+    const timeoutSeconds = Math.ceil(config.timeout / 1000);
+    parts.push("--max-time", String(timeoutSeconds));
+  }
+  if (config.maxRedirects !== undefined) {
+    if (config.maxRedirects === 0) {
+      parts.push("--no-location");
+    } else {
+      parts.push("-L", "--max-redirs", String(config.maxRedirects));
+    }
+  } else {
+    parts.push("-L");
+  }
+  if (config.auth) {
+    const auth = `${config.auth.username}:${config.auth.password}`;
+    parts.push("-u", escapeShellArg(auth));
+  }
+  if (config.proxy) {
+    let proxyUrl;
+    if (typeof config.proxy === "string") {
+      proxyUrl = config.proxy;
+    } else if (config.proxy && typeof config.proxy === "object" && "host" in config.proxy) {
+      const p = config.proxy;
+      const protocol = p.protocol || "http";
+      const authStr = p.auth ? `${p.auth.username}:${p.auth.password}@` : "";
+      proxyUrl = `${protocol}://${authStr}${p.host}:${p.port}`;
+    } else {
+      proxyUrl = String(config.proxy);
+    }
+    if (proxyUrl.startsWith("socks")) {
+      parts.push("--socks5", escapeShellArg(proxyUrl.replace(/^socks[45]a?:\/\//, "")));
+    } else {
+      parts.push("-x", escapeShellArg(proxyUrl));
+    }
+  }
+  if (config.rejectUnauthorized === false || config.insecure) {
+    parts.push("-k");
+  }
+  parts.push("--compressed");
+  const url = config.fullUrl || config.url || "";
+  parts.push(escapeShellArg(String(url)));
+  return parts.join(" ");
+}
+export function fromCurl(curlCommand) {
+  const trimmed = curlCommand.trim();
+  if (!trimmed.toLowerCase().startsWith("curl ")) {
+    throw new Error('Invalid curl command: must start with "curl "');
+  }
+  const tokens = tokenize(trimmed.slice(5));
+  const result = {
+    url: "",
+    method: "GET",
+    headers: {}
+  };
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "-X" || token === "--request") {
+      result.method = tokens[++i]?.toUpperCase() || "GET";
+    } else if (token === "-H" || token === "--header") {
+      const header = tokens[++i];
+      if (header) {
+        const colonIndex = header.indexOf(":");
+        if (colonIndex > 0) {
+          const key = header.slice(0, colonIndex).trim().toLowerCase();
+          const value = header.slice(colonIndex + 1).trim();
+          result.headers[key] = value;
+        }
+      }
+    } else if (token === "-d" || token === "--data" || token === "--data-raw" || token === "--data-binary") {
+      const data = tokens[++i];
+      if (data) {
+        if (result.method === "GET") {
+          result.method = "POST";
+        }
+        if (data.startsWith("{") || data.startsWith("[")) {
+          try {
+            result.body = JSON.parse(data);
+          } catch {
+            result.body = data;
+          }
+        } else {
+          result.body = data;
+        }
+      }
+    } else if (token === "--data-urlencode") {
+      const data = tokens[++i];
+      if (data) {
+        if (result.method === "GET") {
+          result.method = "POST";
+        }
+        result.body = data;
+        if (!result.headers["content-type"]) {
+          result.headers["content-type"] = "application/x-www-form-urlencoded";
+        }
+      }
+    } else if (token === "-G" || token === "--get") {
+      result.method = "GET";
+    } else if (token === "-b" || token === "--cookie") {
+      result.cookies = tokens[++i];
+    } else if (token === "-u" || token === "--user") {
+      const auth = tokens[++i];
+      if (auth) {
+        const colonIndex = auth.indexOf(":");
+        if (colonIndex > 0) {
+          result.auth = {
+            username: auth.slice(0, colonIndex),
+            password: auth.slice(colonIndex + 1)
+          };
+        } else {
+          result.auth = { username: auth, password: "" };
+        }
+      }
+    } else if (token === "-x" || token === "--proxy") {
+      result.proxy = tokens[++i];
+    } else if (token === "--socks5" || token === "--socks5-hostname" || token === "--socks4" || token === "--socks4a") {
+      const proxyHost = tokens[++i];
+      const protocol = token.replace("--", "").replace("-hostname", "");
+      result.proxy = `${protocol}://${proxyHost}`;
+    } else if (token === "-A" || token === "--user-agent") {
+      result.userAgent = tokens[++i];
+      if (result.userAgent) {
+        result.headers["user-agent"] = result.userAgent;
+      }
+    } else if (token === "-L" || token === "--location") {
+      result.followRedirects = true;
+    } else if (token === "--no-location") {
+      result.followRedirects = false;
+    } else if (token === "--max-redirs") {
+      result.maxRedirects = parseInt(tokens[++i] || "0", 10);
+    } else if (token === "--max-time" || token === "-m") {
+      result.timeout = parseInt(tokens[++i] || "0", 10) * 1000;
+    } else if (token === "--connect-timeout") {
+      i++;
+    } else if (token === "-k" || token === "--insecure") {
+      result.insecure = true;
+    } else if (token === "--compressed") {
+      result.compressed = true;
+    } else if (token === "-s" || token === "--silent" || token === "-S" || token === "--show-error") {} else if (token === "-o" || token === "--output") {
+      i++;
+    } else if (token === "-I" || token === "--head") {
+      result.method = "HEAD";
+    } else if (!token.startsWith("-")) {
+      if (!result.url) {
+        result.url = token;
+      }
+    }
+    i++;
+  }
+  const config = {
+    url: result.url,
+    method: result.method,
+    headers: result.headers
+  };
+  if (result.body) {
+    config.body = result.body;
+  }
+  if (result.auth) {
+    config.auth = result.auth;
+  }
+  if (result.proxy) {
+    config.proxy = result.proxy;
+  }
+  if (result.timeout) {
+    config.timeout = result.timeout;
+  }
+  if (result.maxRedirects !== undefined) {
+    config.maxRedirects = result.maxRedirects;
+  }
+  if (result.insecure) {
+    config.rejectUnauthorized = false;
+  }
+  if (result.cookies) {
+    config.headers = config.headers || {};
+    config.headers["cookie"] = result.cookies;
+  }
+  return config;
+}
+function escapeShellArg(arg) {
+  if (arg === "")
+    return "''";
+  if (!/[^a-zA-Z0-9_\-=:/.@]/.test(arg)) {
+    return arg;
+  }
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      i++;
+      continue;
+    }
+    if (char === "\\" && !inSingleQuote) {
+      if (inDoubleQuote) {
+        const nextChar = input[i + 1];
+        if (nextChar === '"' || nextChar === "\\" || nextChar === "$" || nextChar === "`") {
+          escaped = true;
+          i++;
+          continue;
+        }
+      } else {
+        escaped = true;
+        i++;
+        continue;
+      }
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      i++;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      i++;
+      continue;
+    }
+    if ((char === " " || char === "\t" || char === `
+`) && !inSingleQuote && !inDoubleQuote) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      while (i + 1 < input.length && (input[i + 1] === " " || input[i + 1] === "\t" || input[i + 1] === `
+`)) {
+        i++;
+      }
+      i++;
+      continue;
+    }
+    current += char;
+    i++;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rezo",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Lightning-fast, enterprise-grade HTTP client for modern JavaScript. Full HTTP/2 support, intelligent cookie management, multiple adapters (HTTP, Fetch, cURL, XHR), streaming, proxy support (HTTP/HTTPS/SOCKS), and cross-environment compatibility.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -62,11 +62,7 @@
   },
   "dependencies": {
     "tough-cookie": "^5.1.2",
-    "http-proxy-agent": "^7.0.2",
-    "https-proxy-agent": "^7.0.6",
-    "socks-proxy-agent": "^8.0.5",
-    "linkedom": "^0.18.11",
-    "agent-base": "^7.1.4"
+    "linkedom": "^0.18.11"
   },
   "typesVersions": {
     "*": {

package/dist/cache/file-cacher.cjs

@@ -1,264 +0,0 @@
-const fs = require("node:fs");
-const path = require("node:path");
-const { createHash } = require("node:crypto");
-function detectRuntime() {
-  if (typeof globalThis.Bun !== "undefined") {
-    return "bun";
-  }
-  if (typeof globalThis.Deno !== "undefined") {
-    return "deno";
-  }
-  return "node";
-}
-async function createDatabase(dbPath) {
-  const runtime = detectRuntime();
-  if (runtime === "bun") {
-    const { Database } = await import("bun:sqlite");
-    const db = new Database(dbPath);
-    return {
-      run: (sql, ...params) => db.run(sql, ...params),
-      get: (sql, ...params) => db.query(sql).get(...params),
-      all: (sql, ...params) => db.query(sql).all(...params),
-      close: () => db.close()
-    };
-  }
-  if (runtime === "deno") {
-    try {
-      const { Database } = await import("node:sqlite");
-      const db = new Database(dbPath);
-      return {
-        run: (sql, ...params) => db.exec(sql, params),
-        get: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.get(...params);
-        },
-        all: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.all(...params);
-        },
-        close: () => db.close()
-      };
-    } catch {
-      throw new Error("Deno SQLite support requires Node.js compatibility mode");
-    }
-  }
-  const { DatabaseSync } = await import("node:sqlite");
-  const db = new DatabaseSync(dbPath);
-  return {
-    run: (sql, ...params) => db.exec(sql),
-    get: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.get(...params);
-    },
-    all: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.all(...params);
-    },
-    close: () => db.close()
-  };
-}
-async function compressData(data) {
-  try {
-    const zlib = await import("node:zlib");
-    if (typeof zlib.zstdCompressSync === "function") {
-      return zlib.zstdCompressSync(data);
-    }
-    return data;
-  } catch {
-    return data;
-  }
-}
-async function decompressData(data) {
-  try {
-    const zlib = await import("node:zlib");
-    if (typeof zlib.zstdDecompressSync === "function") {
-      return zlib.zstdDecompressSync(data);
-    }
-    return data;
-  } catch {
-    return data;
-  }
-}
-
-class FileCacher {
-  databases = new Map;
-  options;
-  cacheDir;
-  closed = false;
-  constructor(options = {}) {
-    this.options = {
-      cacheDir: options.cacheDir || "./cache",
-      ttl: options.ttl || 604800000,
-      compression: options.compression ?? false,
-      softDelete: options.softDelete ?? false,
-      encryptNamespace: options.encryptNamespace ?? false,
-      maxEntries: options.maxEntries ?? 0
-    };
-    this.cacheDir = path.resolve(this.options.cacheDir);
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-    }
-  }
-  static async create(options = {}) {
-    const cacher = new FileCacher(options);
-    return cacher;
-  }
-  async getDatabase(namespace) {
-    const nsKey = this.options.encryptNamespace ? createHash("md5").update(namespace).digest("hex") : namespace.replace(/[^a-zA-Z0-9_-]/g, "_");
-    if (this.databases.has(nsKey)) {
-      return this.databases.get(nsKey);
-    }
-    const dbPath = path.join(this.cacheDir, `${nsKey}.db`);
-    const db = await createDatabase(dbPath);
-    db.run(`
-      CREATE TABLE IF NOT EXISTS cache (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        expiresAt INTEGER NOT NULL,
-        createdAt INTEGER NOT NULL,
-        compressed INTEGER DEFAULT 0,
-        deleted INTEGER DEFAULT 0
-      )
-    `);
-    db.run("CREATE INDEX IF NOT EXISTS idx_expires ON cache(expiresAt)");
-    db.run("CREATE INDEX IF NOT EXISTS idx_deleted ON cache(deleted)");
-    this.databases.set(nsKey, db);
-    return db;
-  }
-  async set(key, value, ttl, namespace = "default") {
-    if (this.closed)
-      throw new Error("FileCacher is closed");
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const expiresAt = now + (ttl ?? this.options.ttl);
-    let serialized = JSON.stringify(value);
-    let compressed = 0;
-    if (this.options.compression) {
-      try {
-        const compressedData = await compressData(Buffer.from(serialized, "utf-8"));
-        serialized = compressedData.toString("base64");
-        compressed = 1;
-      } catch {}
-    }
-    db.run(`
-      INSERT OR REPLACE INTO cache (key, value, expiresAt, createdAt, compressed, deleted)
-      VALUES (?, ?, ?, ?, ?, 0)
-    `, key, serialized, expiresAt, now, compressed);
-    if (this.options.maxEntries > 0) {
-      const count = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 0");
-      if (count && count.cnt > this.options.maxEntries) {
-        const excess = count.cnt - this.options.maxEntries;
-        db.run(`
-          DELETE FROM cache WHERE key IN (
-            SELECT key FROM cache WHERE deleted = 0 ORDER BY createdAt ASC LIMIT ?
-          )
-        `, excess);
-      }
-    }
-  }
-  async get(key, namespace = "default") {
-    if (this.closed)
-      throw new Error("FileCacher is closed");
-    const db = await this.getDatabase(namespace);
-    const entry = db.get("SELECT * FROM cache WHERE key = ? AND deleted = 0", key);
-    if (!entry)
-      return null;
-    if (entry.expiresAt < Date.now()) {
-      if (this.options.softDelete) {
-        db.run("UPDATE cache SET deleted = 1 WHERE key = ?", key);
-      } else {
-        db.run("DELETE FROM cache WHERE key = ?", key);
-      }
-      return null;
-    }
-    let value = entry.value;
-    if (entry.compressed) {
-      try {
-        const decompressed = await decompressData(Buffer.from(value, "base64"));
-        value = decompressed.toString("utf-8");
-      } catch {
-        return null;
-      }
-    }
-    try {
-      return JSON.parse(value);
-    } catch {
-      return null;
-    }
-  }
-  async has(key, namespace = "default") {
-    if (this.closed)
-      return false;
-    const db = await this.getDatabase(namespace);
-    const entry = db.get("SELECT key, expiresAt FROM cache WHERE key = ? AND deleted = 0", key);
-    if (!entry)
-      return false;
-    return entry.expiresAt >= Date.now();
-  }
-  async delete(key, namespace = "default") {
-    if (this.closed)
-      return false;
-    const db = await this.getDatabase(namespace);
-    if (this.options.softDelete) {
-      db.run("UPDATE cache SET deleted = 1 WHERE key = ?", key);
-    } else {
-      db.run("DELETE FROM cache WHERE key = ?", key);
-    }
-    return true;
-  }
-  async clear(namespace = "default") {
-    if (this.closed)
-      return;
-    const db = await this.getDatabase(namespace);
-    if (this.options.softDelete) {
-      db.run("UPDATE cache SET deleted = 1");
-    } else {
-      db.run("DELETE FROM cache");
-    }
-  }
-  async cleanup(namespace = "default") {
-    if (this.closed)
-      return 0;
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const countBefore = db.get("SELECT COUNT(*) as cnt FROM cache");
-    db.run("DELETE FROM cache WHERE expiresAt < ? OR deleted = 1", now);
-    const countAfter = db.get("SELECT COUNT(*) as cnt FROM cache");
-    return (countBefore?.cnt || 0) - (countAfter?.cnt || 0);
-  }
-  async stats(namespace = "default") {
-    if (this.closed)
-      return { count: 0, expired: 0, deleted: 0 };
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const total = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 0");
-    const expired = db.get("SELECT COUNT(*) as cnt FROM cache WHERE expiresAt < ? AND deleted = 0", now);
-    const deleted = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 1");
-    return {
-      count: total?.cnt || 0,
-      expired: expired?.cnt || 0,
-      deleted: deleted?.cnt || 0
-    };
-  }
-  async close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    for (const db of this.databases.values()) {
-      try {
-        db.close();
-      } catch {}
-    }
-    this.databases.clear();
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  get directory() {
-    return this.cacheDir;
-  }
-}
-
-exports.FileCacher = FileCacher;
-exports.default = FileCacher;
-module.exports = Object.assign(FileCacher, exports);