@browserless/ai 13.9.3

package/scripts/util.js

@@ -0,0 +1,274 @@
+'use strict'
+
+const { createReadStream, createWriteStream, mkdirSync, statSync } = require('node:fs')
+const { createHmac, createHash } = require('node:crypto')
+const { Readable, Transform } = require('node:stream')
+const { pipeline } = require('node:stream/promises')
+const path = require('node:path')
+
+const UNSIGNED = 'UNSIGNED-PAYLOAD'
+const PART_SIZE = 16 * 1024 * 1024
+const DEFAULT_KEY = 'browserless-ai-nano.zip'
+
+const encodeRfc3986 = value =>
+  encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    char => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  )
+
+const hmac = (key, data) => createHmac('sha256', key).update(data, 'utf8').digest()
+const sha256Hex = data => createHash('sha256').update(data).digest('hex')
+const amzNow = () => new Date().toISOString().replace(/[:-]|\.\d{3}/g, '')
+const signingKey = (secret, date, region) =>
+  hmac(hmac(hmac(hmac(`AWS4${secret}`, date), region), 's3'), 'aws4_request')
+
+const parseS3Url = value => {
+  if (!value) return {}
+  try {
+    const url = new URL(value)
+    const parts = url.pathname.split('/').filter(Boolean)
+    return {
+      endpoint: url.origin,
+      bucket: parts[0],
+      key: parts.slice(1).join('/')
+    }
+  } catch {
+    return {}
+  }
+}
+
+const credentials = () => {
+  const fromEnv = parseS3Url(process.env.R2_ENDPOINT)
+  const accountId = process.env.R2_ACCOUNT_ID || process.env.CLOUDFLARE_ACCOUNT_ID
+  return {
+    bucket: process.env.R2_BUCKET || fromEnv.bucket,
+    key: process.env.R2_KEY || fromEnv.key || DEFAULT_KEY,
+    accessKey: process.env.R2_ACCESS_KEY_ID || process.env.AWS_ACCESS_KEY_ID,
+    secretKey: process.env.R2_SECRET_ACCESS_KEY || process.env.AWS_SECRET_ACCESS_KEY,
+    endpoint:
+      fromEnv.endpoint ||
+      process.env.R2_ENDPOINT ||
+      (accountId ? `https://${accountId}.r2.cloudflarestorage.com` : undefined),
+    region: process.env.R2_REGION || 'auto'
+  }
+}
+
+const objectUrl = opts => `${opts.endpoint}/${opts.bucket}/${opts.key}`
+
+const objectPath = (bucket, key) =>
+  `/${encodeRfc3986(bucket)}/${key.split('/').map(encodeRfc3986).join('/')}`
+
+const canonicalQuery = query =>
+  Object.keys(query)
+    .sort()
+    .map(
+      name =>
+        `${encodeRfc3986(name)}=${query[name] === '' ? '' : encodeRfc3986(String(query[name]))}`
+    )
+    .join('&')
+
+const sign = ({
+  method,
+  endpoint,
+  pathname,
+  query = {},
+  extraHeaders = {},
+  accessKey,
+  secretKey,
+  region
+}) => {
+  const amzDate = amzNow()
+  const date = amzDate.slice(0, 8)
+  const host = new URL(endpoint).host
+  const headers = {
+    host,
+    'x-amz-content-sha256': UNSIGNED,
+    'x-amz-date': amzDate,
+    ...extraHeaders
+  }
+  const names = Object.keys(headers)
+    .map(name => name.toLowerCase())
+    .sort()
+  const headerMap = Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [name.toLowerCase(), String(value).trim()])
+  )
+  const canonicalHeaders = names.map(name => `${name}:${headerMap[name]}\n`).join('')
+  const signedHeaders = names.join(';')
+  const canonicalRequest = [
+    method,
+    pathname,
+    canonicalQuery(query),
+    canonicalHeaders,
+    signedHeaders,
+    UNSIGNED
+  ].join('\n')
+  const scope = `${date}/${region}/s3/aws4_request`
+  const stringToSign = ['AWS4-HMAC-SHA256', amzDate, scope, sha256Hex(canonicalRequest)].join('\n')
+  const signature = createHmac('sha256', signingKey(secretKey, date, region))
+    .update(stringToSign)
+    .digest('hex')
+  headers.authorization = `AWS4-HMAC-SHA256 Credential=${accessKey}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`
+  return headers
+}
+
+const signedFetch = async (
+  opts,
+  { method, query = {}, body, contentLength, contentType, signal }
+) => {
+  const pathname = objectPath(opts.bucket, opts.key)
+  const extraHeaders = {}
+  if (contentLength != null) extraHeaders['content-length'] = String(contentLength)
+  if (contentType) extraHeaders['content-type'] = contentType
+  const headers = sign({
+    method,
+    endpoint: opts.endpoint,
+    pathname,
+    query,
+    extraHeaders,
+    accessKey: opts.accessKey,
+    secretKey: opts.secretKey,
+    region: opts.region || 'auto'
+  })
+  const search = canonicalQuery(query)
+  const url = `${opts.endpoint}${pathname}${search ? `?${search}` : ''}`
+  return fetch(url, {
+    method,
+    headers,
+    body,
+    signal,
+    duplex: body && typeof body !== 'string' ? 'half' : undefined
+  })
+}
+
+const request = async (opts, init) => {
+  const res = await signedFetch(opts, init)
+  const text = await res.text()
+  if (!res.ok) throw new Error(`R2 ${init.method} ${res.status}: ${text.slice(0, 500)}`)
+  return { headers: res.headers, text }
+}
+
+const xmlText = (xml, tag) => {
+  const match = xml.match(new RegExp(`<${tag}>([^<]+)</${tag}>`))
+  if (!match) throw new Error(`missing <${tag}> in R2 response`)
+  return match[1]
+}
+
+const prettyBytes = n => {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)} GB`
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)} MB`
+  return `${n} B`
+}
+
+const createReporter = label => {
+  const interactive = process.stderr.isTTY && !process.env.CI
+  let last = 0
+  return (loaded, total, done = false) => {
+    const now = Date.now()
+    if (!done && now - last < (interactive ? 200 : 5000)) return
+    last = now
+    const pct = total ? Math.min(100, Math.floor((loaded / total) * 100)) : 0
+    const line = `${label} ${prettyBytes(loaded)}/${prettyBytes(total)} ${pct}%`
+    process.stderr.write(interactive ? `\r${line}` : `${line}\n`)
+    if (done && interactive) process.stderr.write('\n')
+  }
+}
+
+const toNodeStream = body => {
+  if (!body) throw new Error('empty S3 body')
+  if (typeof body.pipe === 'function') return body
+  if (typeof body.getReader === 'function') return Readable.fromWeb(body)
+  return Readable.from(body)
+}
+
+const DOWNLOAD_TIMEOUT = 15 * 60 * 1000
+
+const downloadFile = async (opts, dest) => {
+  const res = await signedFetch(opts, {
+    method: 'GET',
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT)
+  })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`R2 GET ${res.status}: ${text.slice(0, 500)}`)
+  }
+  const total = Number(res.headers.get('content-length')) || 0
+  const report = createReporter('downloading')
+  let loaded = 0
+  mkdirSync(path.dirname(dest), { recursive: true })
+  await pipeline(
+    toNodeStream(res.body),
+    new Transform({
+      transform (chunk, _enc, cb) {
+        loaded += chunk.length
+        report(loaded, total)
+        cb(null, chunk)
+      }
+    }),
+    createWriteStream(dest)
+  )
+  report(loaded, total, true)
+}
+
+const uploadFile = async (opts, file) => {
+  const { size } = statSync(file)
+  const report = createReporter('uploading')
+  if (size <= PART_SIZE) {
+    report(0, size)
+    await request(opts, {
+      method: 'PUT',
+      body: createReadStream(file),
+      contentLength: size,
+      contentType: 'application/zip'
+    })
+    report(size, size, true)
+    return
+  }
+
+  const created = await request(opts, {
+    method: 'POST',
+    query: { uploads: '' },
+    contentType: 'application/zip'
+  })
+  const uploadId = xmlText(created.text, 'UploadId')
+  const parts = []
+  try {
+    let partNumber = 1
+    for (let start = 0; start < size; start += PART_SIZE, partNumber++) {
+      const end = Math.min(start + PART_SIZE, size) - 1
+      const length = end - start + 1
+      report(start, size)
+      const { headers } = await request(opts, {
+        method: 'PUT',
+        query: { partNumber, uploadId },
+        body: createReadStream(file, { start, end }),
+        contentLength: length
+      })
+      const etag = headers.get('etag')
+      if (!etag) throw new Error(`part ${partNumber} missing ETag`)
+      parts.push({ partNumber, etag })
+      report(end + 1, size)
+    }
+    report(size, size, true)
+    const body =
+      '<CompleteMultipartUpload>' +
+      parts
+        .map(
+          part =>
+            `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${part.etag}</ETag></Part>`
+        )
+        .join('') +
+      '</CompleteMultipartUpload>'
+    await request(opts, {
+      method: 'POST',
+      query: { uploadId },
+      body,
+      contentLength: Buffer.byteLength(body),
+      contentType: 'application/xml'
+    })
+  } catch (error) {
+    await request(opts, { method: 'DELETE', query: { uploadId } }).catch(() => {})
+    throw error
+  }
+}
+
+module.exports = { credentials, downloadFile, objectUrl, uploadFile }

package/src/find-dir.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const path = require('node:path')
+const os = require('node:os')
+const { existsSync, readdirSync, statSync } = require('node:fs')
+
+const cacheRoot = () =>
+  process.env.XDG_CACHE_HOME
+    ? path.join(process.env.XDG_CACHE_HOME, 'browserless-ai')
+    : path.join(os.homedir(), '.cache', 'browserless-ai')
+
+const findDir = (root, predicate) => {
+  if (!existsSync(root)) return
+  if (predicate(root)) return root
+  if (!statSync(root).isDirectory()) return
+  for (const name of readdirSync(root)) {
+    if (name === '_metadata') continue
+    const next = path.join(root, name)
+    if (statSync(next).isDirectory()) {
+      const found = findDir(next, predicate)
+      if (found) return found
+    }
+  }
+}
+
+const hasFile = (root, file) => findDir(root, current => existsSync(path.join(current, file)))
+
+module.exports = { cacheRoot, findDir, hasFile }

package/src/index.js

@@ -0,0 +1,313 @@
+'use strict'
+
+const debug = require('debug-logfmt')('browserless:ai')
+const { crc32 } = require('node:zlib')
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+
+const { cacheRoot, hasFile } = require('./find-dir')
+const runAi = require('./run-ai')
+
+const withContext = async (getBrowserless, fn) => {
+  let teardown
+  const browserless = await getBrowserless(done => (teardown = done))
+  try {
+    return await fn(browserless)
+  } finally {
+    if (teardown) await teardown()
+  }
+}
+
+const createMethod =
+  (getBrowserless, spec) =>
+    (url, { timeout = TIMEOUT, ...opts } = {}) =>
+      withContext(getBrowserless, browserless =>
+        browserless.evaluate(page => page.evaluate(runAi, { ...opts, ...spec }), { timeout })(url)
+      )
+
+const OVERRIDE_SEP = process.platform === 'win32' ? '|' : ':'
+
+const FEATURES = 'OnDeviceModelForceCpuBackend,OptimizationHints'
+
+const TIMEOUT = 300000
+
+const readVarint = (buf, offset) => {
+  let value = 0
+  let shift = 0
+  while (offset < buf.length) {
+    const byte = buf[offset++]
+    value |= (byte & 0x7f) << shift
+    if ((byte & 0x80) === 0) return { value, offset }
+    shift += 7
+  }
+  throw new Error('truncated protobuf varint')
+}
+
+const writeVarint = n => {
+  const bytes = []
+  while (n > 0x7f) {
+    bytes.push((n & 0x7f) | 0x80)
+    n >>>= 7
+  }
+  bytes.push(n)
+  return Buffer.from(bytes)
+}
+
+const skipTextSafety = buf => {
+  if (!buf.length || buf[0] !== 0x0a) return buf
+  const { value: length, offset } = readVarint(buf, 1)
+  const inner = buf.subarray(offset, offset + length)
+  if (inner.subarray(-2).equals(Buffer.from([0x28, 0x01]))) return buf
+  const patched = Buffer.concat([inner, Buffer.from([0x28, 0x01])])
+  return Buffer.concat([
+    Buffer.from([0x0a]),
+    writeVarint(patched.length),
+    patched,
+    buf.subarray(offset + length)
+  ])
+}
+
+const zipStore = entries => {
+  const locals = []
+  const centrals = []
+  let offset = 0
+  for (const [name, data] of entries) {
+    const nameBuf = Buffer.from(name)
+    const crc = crc32(data)
+    const local = Buffer.alloc(30)
+    local.writeUInt32LE(0x04034b50, 0)
+    local.writeUInt16LE(20, 4)
+    local.writeUInt32LE(crc, 14)
+    local.writeUInt32LE(data.length, 18)
+    local.writeUInt32LE(data.length, 22)
+    local.writeUInt16LE(nameBuf.length, 26)
+    locals.push(local, nameBuf, data)
+    const central = Buffer.alloc(46)
+    central.writeUInt32LE(0x02014b50, 0)
+    central.writeUInt16LE(20, 4)
+    central.writeUInt16LE(20, 6)
+    central.writeUInt32LE(crc, 16)
+    central.writeUInt32LE(data.length, 20)
+    central.writeUInt32LE(data.length, 24)
+    central.writeUInt16LE(nameBuf.length, 28)
+    central.writeUInt32LE(offset, 42)
+    centrals.push(central, nameBuf)
+    offset += 30 + nameBuf.length + data.length
+  }
+  const localBuf = Buffer.concat(locals)
+  const centralBuf = Buffer.concat(centrals)
+  const end = Buffer.alloc(22)
+  end.writeUInt32LE(0x06054b50, 0)
+  end.writeUInt16LE(entries.length, 8)
+  end.writeUInt16LE(entries.length, 10)
+  end.writeUInt32LE(centralBuf.length, 12)
+  end.writeUInt32LE(localBuf.length, 16)
+  return Buffer.concat([localBuf, centralBuf, end])
+}
+
+const ADAPTATIONS = [
+  {
+    name: 'prompt',
+    target: 49,
+    flag: 'OPTIMIZATION_TARGET_MODEL_EXECUTION_FEATURE_PROMPT_API',
+    skipSafety: true
+  },
+  {
+    name: 'summarize',
+    target: 51,
+    flag: 'OPTIMIZATION_TARGET_MODEL_EXECUTION_FEATURE_SUMMARIZE',
+    skipSafety: true
+  },
+  {
+    name: 'detect',
+    target: 2,
+    flag: 'OPTIMIZATION_TARGET_LANGUAGE_DETECTION',
+    skipSafety: false
+  }
+]
+
+const packAdaptation = (dir, { name, skipSafety }) => {
+  const dest = path.join(
+    os.tmpdir(),
+    `browserless-ai-${name}-${process.pid}-${process.hrtime.bigint()}.crx3`
+  )
+  const read = file => {
+    const filePath = path.join(dir, file)
+    return fs.existsSync(filePath) ? fs.readFileSync(filePath) : Buffer.alloc(0)
+  }
+  let config = read('on_device_model_execution_config.pb')
+  if (config.length && skipSafety) config = skipTextSafety(config)
+  const files = [
+    ['model.tflite', read('model.tflite')],
+    ['model-info.pb', read('model-info.pb')]
+  ]
+  if (config.length) files.push(['on_device_model_execution_config.pb', config])
+  fs.writeFileSync(dest, zipStore(files))
+  return dest
+}
+
+const resolveAdaptations = adaptationPath => {
+  const stat = fs.statSync(adaptationPath)
+  if (stat.isFile()) {
+    return [`OPTIMIZATION_TARGET_LANGUAGE_DETECTION${OVERRIDE_SEP}${path.resolve(adaptationPath)}`]
+  }
+
+  const pairs = []
+  for (const feature of ADAPTATIONS) {
+    const dir =
+      hasFile(path.join(adaptationPath, feature.name), 'model-info.pb') ||
+      hasFile(path.join(adaptationPath, String(feature.target)), 'model-info.pb')
+    if (dir) pairs.push(`${feature.flag}${OVERRIDE_SEP}${packAdaptation(dir, feature)}`)
+    debug('adaptation', { name: feature.name, dir: dir || false })
+  }
+  return pairs
+}
+
+const chromeSupport = (...parts) =>
+  process.platform === 'darwin'
+    ? path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome', ...parts)
+    : undefined
+
+const resolveModelPath = dir => {
+  if (dir) return hasFile(dir, 'weights.bin')
+  const chrome = chromeSupport('OptGuideOnDeviceModel')
+  return hasFile(cacheRoot(), 'weights.bin') || (chrome && hasFile(chrome, 'weights.bin'))
+}
+
+const resolveAdaptationPath = dir => {
+  if (dir) return fs.existsSync(dir) ? dir : undefined
+  if (hasFile(cacheRoot(), 'model-info.pb')) return cacheRoot()
+  const store = chromeSupport('optimization_guide_model_store')
+  return store && fs.existsSync(store) ? store : undefined
+}
+
+const launch = ({
+  dir = process.env.BROWSERLESS_AI_DIR,
+  userDataDir = process.env.BROWSERLESS_AI_PROFILE,
+  timeout = TIMEOUT,
+  protocolTimeout = timeout
+} = {}) => {
+  const modelPath = resolveModelPath(dir)
+  const adaptationPath = resolveAdaptationPath(dir)
+
+  const { defaultArgs } = require('browserless').driver
+  const args = defaultArgs
+    .filter(arg => arg !== '--no-startup-window')
+    .map(arg => (arg.startsWith('--enable-features=') ? `${arg},${FEATURES}` : arg))
+  if (process.env.BROWSERLESS_AI_DUMPIO) {
+    args.push('--enable-logging=stderr', '--vmodule=optimization_guide*=1,on_device_model*=2')
+  }
+  args.push('--disable-model-download-verification')
+  if (modelPath) {
+    args.push(`--optimization-guide-ondevice-model-execution-override=${modelPath}`)
+  }
+  if (adaptationPath) {
+    const pairs = resolveAdaptations(adaptationPath)
+    if (pairs.length) args.push(`--optimization-guide-model-override=${pairs.join(',')}`)
+  }
+  const weights = modelPath && path.join(modelPath, 'weights.bin')
+  debug('launch', {
+    dir: dir || false,
+    modelPath: modelPath || false,
+    weightsBytes: weights && fs.existsSync(weights) ? fs.statSync(weights).size : 0,
+    adaptationPath: adaptationPath || false,
+    overrides: args.filter(
+      arg =>
+        arg.includes('optimization-guide') ||
+        arg.includes('PromptAPI') ||
+        arg.includes('Summarization')
+    )
+  })
+  return {
+    timeout,
+    protocolTimeout,
+    ...(userDataDir && { userDataDir }),
+    ...(process.env.BROWSERLESS_AI_DUMPIO && { dumpio: true }),
+    ...(process.env.CI && { headless: false }),
+    args
+  }
+}
+
+const createMethods = getBrowserless => {
+  const prompt = createMethod(getBrowserless, { api: 'prompt' })
+  return {
+    prompt,
+    extract: (url, opts = {}) => {
+      if (!opts.schema && !opts.responseConstraint) {
+        return Promise.reject(new Error('extract requires schema'))
+      }
+      return prompt(url, { temperature: 0, topK: 1, ...opts })
+    },
+    summarize: createMethod(getBrowserless, { api: 'summarize' }),
+    translate: createMethod(getBrowserless, { api: 'translate' }),
+    detectLanguage: createMethod(getBrowserless, { api: 'detectLanguage' }),
+    capabilities: ({ timeout = TIMEOUT, url = 'https://example.com' } = {}) =>
+      withContext(getBrowserless, async browserless => {
+        const ctors = await browserless.evaluate(
+          page =>
+            page.evaluate(() => ({
+              languageModel: typeof globalThis.LanguageModel,
+              summarizer: typeof globalThis.Summarizer,
+              translator: typeof globalThis.Translator,
+              languageDetector: typeof globalThis.LanguageDetector
+            })),
+          { timeout: Math.min(timeout, 30000) }
+        )(url)
+        debug('ctors', ctors)
+        const started = Date.now()
+        let available
+        let lastError
+        for (;;) {
+          const left = timeout - (Date.now() - started)
+          if (left <= 0) break
+          try {
+            available = await browserless.evaluate(
+              page => page.evaluate(runAi, { api: 'availability' }),
+              { timeout: Math.min(20000, left) }
+            )(url)
+            lastError = undefined
+          } catch (error) {
+            lastError = error
+            if (left <= 20000) throw error
+            await new Promise(resolve => setTimeout(resolve, 2000))
+            continue
+          }
+          const apis = available.apis || available
+          const pending = ['languageModel', 'summarizer', 'languageDetector'].some(
+            api => apis[api] === 'downloading'
+          )
+          if (!pending) break
+          await new Promise(resolve => setTimeout(resolve, 2000))
+        }
+        if (!available) throw lastError || new Error('capabilities timed out')
+        debug('capabilities', available.apis || available, available.env)
+        return available.apis || available
+      })
+  }
+}
+
+const createAi = (input = {}) => {
+  if (typeof input === 'function') return createMethods(input)
+
+  const browser = require('browserless')(launch(input))
+  const methods = createMethods(async teardown => {
+    const browserless = await browser.createContext()
+    teardown(() => browserless.destroyContext())
+    return browserless
+  })
+  methods.close = () => browser.close()
+  return methods
+}
+
+module.exports = createAi
+module.exports.launch = launch
+module.exports.unpack = require('./unpack')
+module.exports.download = dest => {
+  const { credentials, downloadFile } = require('../scripts/util')
+  const env = credentials()
+  if (!env.endpoint || !env.bucket || !env.accessKey || !env.secretKey) {
+    throw new Error('set R2_ENDPOINT, R2_ACCESS_KEY_ID, and R2_SECRET_ACCESS_KEY')
+  }
+  return downloadFile(env, dest)
+}