File _wrapper.js of Package chromium122 - openSUSE Build Service

Overview Repositories Revisions Requests Users Attributes Meta

File _wrapper.js of Package chromium122

#!/usr/bin/env node

// https://nodejs.org/api/cli.html#--input-typetype
// #!/usr/bin/env -S node --input-type=module
// --input-type can only be used with string input via --eval, --print, or STDIN
//
// import * as os from 'node:os'
// import * as fs from 'node:fs/promises'
// import * as path from 'node:path'
// import * as process from 'node:process'
// import * as child_process from 'node:child_process'
// import * as readline from 'node:readline/promises'

const os = require('node:os')
const fs = require('node:fs/promises')
const path = require('node:path')
const process = require('node:process')
const child_process = require('node:child_process')
const readline = require('node:readline/promises')

let FLAGS = ''
let FLAGS_FILE = ''
let APP_PATH = ''
let APP_DESKTOP = ''
let ENVIRON = true
let CHANNEL = 'stable'
let VENDOR = 'Arch Linux'

// APP_PATH = '/usr/lib/chromium/chromium'

// ENVIRON = false
// APP_PATH = '/usr/lib/brave-bin/brave-browser'
// APP_DESKTOP = 'brave-browser.desktop'
// FLAGS_FILE = 'brave-flags.conf'

async function setEnviron(appName) {
  process.env['CHROME_WRAPPER'] = process.argv0
  // desktop-entry-spec, see https://specifications.freedesktop.org/
  if (!APP_DESKTOP) APP_DESKTOP = `${appName}.desktop`
  if (process.env.XDG_DATA_DIRS) {
    for (const i of process.env.XDG_DATA_DIRS.split(path.delimiter)) {
      try {
        await fs.access(path.resolve(i, 'applications', APP_DESKTOP))
        process.env.CHROME_DESKTOP = APP_DESKTOP
        break
      } catch (error) {
        if (error.code !== 'ENOENT') console.error(error)
      }
    }
  }
  // docs/user_data_dir.md
  // chrome/common/channel_info_posix.cc
  // chrome/tools/build/linux/chrome-wrapper
  // stable extended beta unstable
  // brave
  //     build/linux/BUILD.gn
  //     build/linux/channels.gni
  //     stable beta dev/unstable nightly
  // Custom version string for this release. This can be used to add a downstream
  // vendor string or release channel information.
  // process.env['CHROME_VERSION_EXTRA'] = CHANNEL
  process.env['CHROME_VERSION_EXTRA'] = VENDOR
  process.env['GNOME_DISABLE_CRASH_DIALOG'] = 'SET_BY_GOOGLE_CHROME'
}

function displayFlags(flags) {
  console.log()
  if (!flags.length) return console.log('no flags found')
  console.log('found flags:')
  for(const flag of flags) console.log(`\t${flag}`)
}

function launchApp(flags) {
  let subprocess = child_process.spawn(APP_PATH, flags, {
    detached: true,
    stdio: 'ignore'
  })
  subprocess.on('error', (error) => {
    let message = error.message
    switch(error.code) {
    case 'EACCES':
      message = 'Permission denied'
      break
    case 'ENOENT':
      message = 'No such file or directory'
      break
    }
    console.error(`${APP_PATH}: ${message}`)
  })
  subprocess.unref()
}

function purifyArg(arg) {
  if (!arg.includes('=')) return [arg, '']

let sep = arg.indexOf('=')
  let [key, value] = [arg.slice(0, sep), arg.slice(sep + 1)]
  if (value[0] == value[value.length - 1] && ["'", '"'].includes(value[0])){
    value = value.slice(1, -1)
  }
  return [key, value]
}

async function readFlags(files) {
  let switchFlags = []
  let featureFlags = {}
  await Promise.all(files.map(async (file) => {
    try {
      await fs.access(file, fs.constants.R_OK)
      const fd = await fs.open(file)
      const fileStream = fd.createReadStream({encoding: 'utf-8'})

const rl = readline.createInterface({
        input: fileStream,
        crlfDelay: Infinity
      })
      for await (let line of rl) {
        line = line.trim()
        if (!line || line.startsWith('#')) continue

let [key, value] = purifyArg(line)
        // console.log(`key: ${key}, value: ${value}`)
        if (line.startsWith('--enable-features=') ||
          line.startsWith('--disable-features=')) {
          // let sep = line.indexOf('=')
          // let [key, value] = [line.slice(0, sep), line.slice(sep + 1)]
          featureFlags[key] ? featureFlags[key].push(value) : featureFlags[key] = [value]
        } else switchFlags.push(value ? [key, value].join('=') : key)
      }
    } catch (error) {
      if (error.code !== 'ENOENT') console.error(error)
    }
  }))
  // console.log(switchFlags)
  // console.log(featureFlags)
  let flags = []
  for (const arg of FLAGS.split(' ')) {
    if (!arg) continue
    let [key, value] = purifyArg(arg)
    flags.push(value ? [key, value].join('=') : key)
  }
  flags.push(...switchFlags)
  for (const [key, value] of Object.entries(featureFlags)) {
    flags.push(`${key}=${value.join(',')}`)
  }
  // console.log(flags)
  return flags
}

async function checkApp(debug=false) {
  let appName = APP_PATH ?
    path.basename(APP_PATH) :
    // path.basename(import.meta.url, path.extname(import.meta.url))
    path.basename(__filename, path.extname(__filename))

if (!APP_PATH)
    APP_PATH = path.resolve(path.sep, 'usr', 'lib', appName, appName)
  // console.log(`appName: ${appName}`)
  // console.log(`appPath: ${APP_PATH}`)

if (ENVIRON)
    await setEnviron(appName)

if (!FLAGS_FILE)
    FLAGS_FILE = `${appName}-flags.conf`

let systemFlagsFiles = [
    path.resolve(path.sep, 'etc', appName, FLAGS_FILE),
    path.resolve(path.sep, 'etc', FLAGS_FILE)]
  let userConfigDir = process.env.XDG_CONFIG_HOME || os.homedir()
  let userFlagsFiles = [
    path.resolve(userConfigDir, '.config', appName, FLAGS_FILE),
    path.resolve(userConfigDir, '.config', FLAGS_FILE)]
  let flags = await readFlags([...systemFlagsFiles, ...userFlagsFiles])

if (debug) {
    try {
      if (appName != '_wrapper') await fs.access(APP_PATH)
      console.log(`${APP_PATH}`)
    } catch (error) {
      if (error.code === 'ENOENT') console.error(`${APP_PATH}: No such file or directory`)
      else console.error(error)
      process.exit(1)
    }

if (ENVIRON) {
      console.log(`${os.EOL}environment variables:`)
      for (const i of [
        'CHROME_WRAPPER',
        'CHROME_DESKTOP',
        'CHROME_VERSION_EXTRA',
        'GNOME_DISABLE_CRASH_DIALOG']) {
        if (!process.env[i]) continue
        console.log(`\t${i}="${process.env[i]}"`)
      }
    }

console.log(`${os.EOL}flags files:`)
    for (const file of [...systemFlagsFiles, ...userFlagsFiles]) {
      try {
        await fs.access(file)
        console.log(`\t${file}`)
      } catch (error) {
        if (error.code !== 'ENOENT') console.error(error)
        else console.log(`\t${file} [not found]`)
      }
    }
  }

return flags
}

function main() {
  process.on('SIGINT', () => {
    process.exit(130)
  })

let debug = false
  // console.log(typeof process.argv, Array.isArray(process.argv))
  // console.log(process.argv)
  if (process.argv.includes('--debug'))
    debug = true

checkApp(debug).then(flags => {
    // console.log(flags)
    debug ? displayFlags(flags) : launchApp(flags)
  })
}

main()

openSUSE Build Service is sponsored by