curlnapi-node 0.1.8

package/index.js

@@ -0,0 +1,56 @@
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+
+function tryRequire(name) {
+  try { return require(name) } catch { return null }
+}
+
+function isMuslFromFilesystem() {
+  try { return fs.readFileSync('/usr/bin/ldd', 'utf-8').includes('musl') } catch { return null }
+}
+function isMuslFromReport() {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) return null
+  if (report.header && report.header.glibcVersionRuntime) return false
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(f => f.includes('libc.musl-') || f.includes('ld-musl-'))) return true
+  }
+  return false
+}
+function isMusl() {
+  if (os.platform() !== 'linux') return false
+  const a = isMuslFromFilesystem()
+  if (a !== null) return a
+  const b = isMuslFromReport()
+  if (b !== null) return b
+  try { return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl') } catch { return false }
+}
+
+function resolveNative() {
+  const platform = os.platform()
+  const arch = os.arch()
+  const candidates = []
+  if (platform === 'win32' && arch === 'x64') candidates.push('@wengo/curlnapi-win32-x64-msvc')
+  if (platform === 'linux' && arch === 'x64') candidates.push(isMusl() ? '@wengo/curlnapi-linux-x64-musl' : '@wengo/curlnapi-linux-x64-gnu')
+  if (platform === 'darwin' && arch === 'x64') candidates.push('curlnapi-darwin-x64')
+  if (platform === 'darwin' && arch === 'arm64') candidates.push('curlnapi-darwin-arm64')
+  for (const pkg of candidates) {
+    const mod = tryRequire(pkg)
+    if (mod) return mod
+  }
+  const root = path.resolve(__dirname, '..')
+  const lib64 = path.join(root, 'lib64')
+  const bin = path.join(lib64, 'bin')
+  if (platform === 'win32') {
+    const paths = [lib64, bin, process.env.PATH || ''].filter(Boolean)
+    process.env.PATH = paths.join(';')
+  }
+  return require(path.join(root, 'build', 'Release', 'curlnapi.node'))
+}
+
+module.exports = resolveNative()

package/index.wrapper.js

@@ -0,0 +1,79 @@
+const { castToTypedArray } = require('./request.js')
+let native = null
+try {
+  native = require('./index.js')
+} catch (e) {
+  throw new Error(`curl_cffi couldn't load native bindings. Set VERBOSE=1 for details.`, process.env['VERBOSE'] === '1' ? { cause: e } : undefined)
+}
+
+function canonicalizeHeaders(headers) {
+  if (typeof Headers !== 'undefined' && headers instanceof Headers) return [...headers.entries()]
+  if (Array.isArray(headers)) return headers
+  if (headers && typeof headers === 'object') return Object.entries(headers)
+  return []
+}
+
+function headersToObject(headers) {
+  if (!headers) return undefined
+  const entries = canonicalizeHeaders(headers)
+  return Object.fromEntries(entries)
+}
+
+async function parseFetchOptions(resource, init) {
+  let url
+  let options = { ...init }
+  if (typeof Request !== 'undefined' && resource instanceof Request) {
+    url = resource.url
+    options = { method: resource.method, headers: resource.headers, body: resource.body, ...init }
+  } else if (resource && resource.toString) {
+    url = resource.toString()
+  } else {
+    url = resource
+  }
+  options.headers = canonicalizeHeaders(options?.headers)
+  if (options?.body) {
+    const { body, type } = await castToTypedArray(options.body)
+    options.body = body
+    if (type && !options.headers.some(([k]) => String(k).toLowerCase() === 'content-type')) {
+      options.headers.push(['Content-Type', type])
+    }
+  } else {
+    delete options.body
+  }
+  const out = { url, method: options.method, headers: options.headers, body: options.body, signal: options.signal }
+  if (typeof options.timeout === 'number') out.timeout = options.timeout
+  return out
+}
+
+class Impit extends native.Impit {
+  constructor(options) {
+    const jsCookieJar = options?.cookieJar
+    super({
+      ...options,
+      cookieJar: jsCookieJar ? {
+        setCookie: async (args) => jsCookieJar.setCookie?.bind?.(jsCookieJar)(...args),
+        getCookieString: async (args) => jsCookieJar.getCookieString?.bind?.(jsCookieJar)(args),
+      } : undefined,
+      headers: headersToObject(options?.headers),
+    })
+  }
+  async fetch(resource, init) {
+    const { url, signal, ...options } = await parseFetchOptions(resource, init)
+    const waitForAbort = new Promise((_, reject) => {
+      signal?.throwIfAborted?.()
+      signal?.addEventListener?.('abort', () => reject(signal.reason), { once: true })
+    })
+    const response = super.fetch(url, options)
+    const originalResponse = await Promise.race([response, waitForAbort])
+    signal?.throwIfAborted?.()
+    signal?.addEventListener?.('abort', () => { originalResponse.abort() })
+    if (typeof Headers !== 'undefined') {
+      Object.defineProperty(originalResponse, 'headers', { value: new Headers(originalResponse.headers) })
+    }
+    return originalResponse
+  }
+}
+
+module.exports.Impit = Impit
+module.exports.ImpitWrapper = native.ImpitWrapper
+module.exports.ImpitResponse = native.ImpitResponse

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "curlnapi-node",
+  "version": "0.1.8",
+  "private": false,
+  "description": "Node binding for curl-impersonate with a requests-like API",
+  "main": "index.wrapper.js",
+  "scripts": {
+    "test": "node examples/test.js"
+  },
+  "optionalDependencies": {
+    "@wengo/curlnapi-win32-x64-msvc": "^0.1.0",
+    "@wengo/curlnapi-linux-x64-gnu": "^0.1.0"
+  }
+}

package/request.js

@@ -0,0 +1,72 @@
+async function generateMultipartFormData(formData) {
+  const boundary = `----formdata-curlcffi-${`${Math.random().toString().slice(0, 5)}`.padStart(11, '0')}`
+  const prefix = `--${boundary}\r\nContent-Disposition: form-data`
+  const escape = (str) => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
+  const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n')
+  const blobParts = []
+  const rn = new Uint8Array([13, 10])
+  const textEncoder = new TextEncoder()
+  for (const [name, value] of formData) {
+    if (typeof value === 'string') {
+      const chunk = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"` + `\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
+      blobParts.push(chunk)
+    } else {
+      const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' + `Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`)
+      blobParts.push(chunk, value, rn)
+    }
+  }
+  const chunk = textEncoder.encode(`--${boundary}--\r\n`)
+  blobParts.push(chunk)
+  const action = async function* () { for (const part of blobParts) { if (part.stream) { yield* part.stream() } else { yield part } } }
+  const parts = []
+  for await (const part of action()) {
+    if (part instanceof Uint8Array) parts.push(part)
+    else if (typeof Blob !== 'undefined' && part instanceof Blob) {
+      const arrayBuffer = await part.arrayBuffer()
+      parts.push(new Uint8Array(arrayBuffer))
+    } else {
+      throw new TypeError('Unsupported part type')
+    }
+  }
+  const body = new Uint8Array(parts.reduce((acc, p) => acc + p.length, 0))
+  let offset = 0
+  for (const p of parts) { body.set(p, offset); offset += p.length }
+  return { body, type: `multipart/form-data; boundary=${boundary}` }
+}
+
+async function castToTypedArray(body) {
+  let typedArray = body
+  let type = ''
+  if (typeof body === 'string') {
+    typedArray = new TextEncoder().encode(body)
+    type = 'text/plain;charset=UTF-8'
+  } else if (typeof URLSearchParams !== 'undefined' && typedArray instanceof URLSearchParams) {
+    typedArray = new TextEncoder().encode(body.toString())
+    type = 'application/x-www-form-urlencoded;charset=UTF-8'
+  } else if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) {
+    typedArray = new Uint8Array(body.slice())
+  } else if (ArrayBuffer.isView(body)) {
+    typedArray = new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength))
+  } else if (typeof Blob !== 'undefined' && body instanceof Blob) {
+    typedArray = new Uint8Array(await body.arrayBuffer())
+    type = body.type
+  } else if (typeof FormData !== 'undefined' && body instanceof FormData) {
+    return await generateMultipartFormData(body)
+  } else if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+    const reader = body.getReader()
+    const chunks = []
+    let done = false
+    while (!done) {
+      const { done: streamDone, value } = await reader.read()
+      done = streamDone
+      if (value) chunks.push(value)
+    }
+    const total = chunks.reduce((acc, c) => acc + c.length, 0)
+    typedArray = new Uint8Array(total)
+    let offset = 0
+    for (const c of chunks) { typedArray.set(c, offset); offset += c.length }
+  }
+  return { body: typedArray, type }
+}
+
+exports.castToTypedArray = castToTypedArray