@honor-minigame/cli/server/openBrowser.js

honor minigame pack cli

/**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file at
 * https://github.com/facebook/create-react-app/blob/master/LICENSE
 */
import {require} from '../packager/lib/require.js'
import { lookupChromeWindows } from './sniffer-windows.js'

const open = require('open')
const execa = require('execa')
const chalk = require('chalk')
const execSync = require('child_process').execSync
const chromeLauncher = require('chrome-simple-launcher')
let puppeteer = require('puppeteer')
const path = require('path')

// https://github.com/sindresorhus/open#app
const OSX_CHROME = 'google chrome'

const Actions = Object.freeze({
  NONE: 0,
  BROWSER: 1,
  SCRIPT: 2
})

function getBrowserEnv () {
  // Attempt to honor this environment variable.
  // It is specific to the operating system.
  // See https://github.com/sindresorhus/open#app for documentation.
  const value = process.env.BROWSER
  let action
  if (!value) {
    // Default.
    action = Actions.BROWSER
  } else if (value.toLowerCase().endsWith('.js')) {
    action = Actions.SCRIPT
  } else if (value.toLowerCase() === 'none') {
    action = Actions.NONE
  } else {
    action = Actions.BROWSER
  }
  return { action, value }
}

function executeNodeScript (scriptPath, url) {
  const extraArgs = process.argv.slice(2)
  const child = execa('node', [scriptPath, ...extraArgs, url], {
    stdio: 'inherit'
  })
  child.on('close', code => {
    if (code !== 0) {
      console.log()
      console.log(
        chalk.red(
          'The script specified as BROWSER environment variable failed.'
        )
      )
      console.log(chalk.cyan(scriptPath) + ' exited with code ' + code + '.')
      console.log()
    }
  })
  return true
}

let browserDev
let chromePath
async function startBrowserProcess (browser, url) {
  // If we're on OS X, the user hasn't specifically
  // requested a different browser, we can try opening
  // Chrome with AppleScript. This lets us reuse an
  // existing tab when possible instead of creating a new one.
  const shouldTryOpenChromeWithAppleScript =
    process.platform === 'darwin' &&
    (typeof browser !== 'string' || browser === OSX_CHROME)

  if (shouldTryOpenChromeWithAppleScript) {
    if (isChromeInstalled()) {
      try {
        // Try our best to reuse existing tab
        // on OS X Google Chrome with AppleScript
        execSync('ps cax | grep "Google Chrome"')
        execSync('osascript openChrome.applescript "' + encodeURI(url) + '"', {
          cwd: __dirname,
          stdio: 'ignore'
        })
        return true
      } catch (err) {
        // Ignore errors.
      }
    } else {
      try {
        await puppeteer.launch({
          headless: false,
          defaultViewport: null,
          ignoreDefaultArgs: ['--enable-automation', '--enable-blink-features=IdleDetection'],
          args: ['--start-maximized', '--no-default-browser-check']
        })
      } catch (err) {
        try {
          console.warn('检测到本地没有安装 Chrome 浏览器，正在尝试安装 puppeteer 依赖~')
          // Try our best to reuse existing tab
          // on OS X Google Chrome with AppleScript
          execSync('sudo PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=false npm install puppeteer puppeteer-core', {
            cwd: __dirname,
            stdio: 'inherit'
          })

          try {
            // 安装完成后，动态构造 require 路径，绕开缓存
            const puppeteerPath = path.join(__dirname, '../../node_modules', 'puppeteer')
            delete require.cache[require.resolve(puppeteerPath)]
            puppeteer = require(puppeteerPath)
            console.log('安装 puppeteer 成功~')
          } catch (err) {
            // 安装完成后，动态构造 require 路径，绕开缓存
            puppeteer = require('puppeteer')
          }
        } catch (err) {
          // Ignore errors.
          console.error('请安装 Chrome 浏览器~')
          return false
        }
      }
    }
  }

  // Another special case: on OS X, check if BROWSER has been set to "open".
  // In this case, instead of passing the string `open` to `open` function (which won't work),
  // just ignore it (thus ensuring the intended behavior, i.e. opening the system browser):
  // https://github.com/facebook/create-react-app/pull/1690#issuecomment-283518768
  if (process.platform === 'darwin' && browser === 'open') {
    browser = undefined
  }

  // Fallback to open
  // (It will always open new tab)
  try {
    try {
      if (browserDev) {
        const pages = await browserDev.pages()
        if (pages && pages.length > 0) {
          for (const page of pages) {
            // 检查页面是否已关闭
            if (await page.isClosed()) continue

            // 获取页面的当前 URL
            const currentUrl = await page.url()

            // 检查当前 URL 是否与目标 URL 匹配
            if (currentUrl === url) {
              console.info('刷新当前已存在的调试页面：' + url)

              // 刷新当前页面
              await page.reload()

              // 将浏览器窗口拉到前台
              await page.bringToFront()

              return true
            }
          }

          const page = await browserDev.newPage()
          await page.goto(url) // 打开网页
          await page.bringToFront() // 将浏览器窗口拉到前台
          return true
        }
      }

      // 强制关闭浏览器窗口
      if (browserDev) {
        await browserDev.close()
      }

      if (!chromePath && !shouldTryOpenChromeWithAppleScript) {
        chromePath = await lookupChromeWindows()
      }

      const options = {
        headless: false,
        defaultViewport: null,
        ignoreDefaultArgs: ['--enable-automation', '--enable-blink-features=IdleDetection'],
        args: ['--start-maximized', '--no-default-browser-check',
          
        ]
      }
      if (chromePath && !shouldTryOpenChromeWithAppleScript) {
        options.executablePath = chromePath
      }
      browserDev = await puppeteer.launch(options)
      const pages = await browserDev.pages()
      const page = pages[0]
      await page.goto(url) // 打开网页
      await page.bringToFront() // 将浏览器窗口拉到前台
    } catch (e) {
      if (shouldTryOpenChromeWithAppleScript) {
        console.warn('若不想安装chrome浏览器，请检查puppeteer是否安装成功，并重启qg server服务~')
        return false
      }
      console.error(e)
      const error = () => {
        var options = { app: browser, url: true }
        open(url, options).catch(() => {}) // Prevent `unhandledRejection` error.
      }
      chromeLauncher.launch(url, {
        onError: error
      }).catch(() => {
        var options = { app: browser, url: true }
        open(url, options).catch(() => {}) // Prevent `unhandledRejection` error.
      })
    }
  } catch (err) {
    return false
  }
}

function isChromeInstalled () {
  try {
    // 方法1：直接检查应用是否存在（更快更轻量）
    const chromePath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
    const fs = require('fs');
    if (fs.existsSync(chromePath)) {
      return true;
    }

    // 方法2：或者使用 mdfind 查找（更全面）
    try {
      const result = execSync('mdfind "kMDItemCFBundleIdentifier == \'com.google.Chrome\'"').toString();
      return result.includes('Google Chrome.app');
    } catch {
      const standardPath = '/Applications/Google Chrome.app';
      const userPath = path.join(process.env.HOME, 'Applications/Google Chrome.app');
      
      return fs.existsSync(standardPath) || fs.existsSync(userPath);
    }
  } catch (error) {
    console.error('Error checking Chrome installation:', error.message);
    return false;
  }
}

/**
 * Reads the BROWSER environment variable and decides what to do with it. Returns
 * true if it opened a browser or ran a node.js script, otherwise false.
 */
const openBrowser = function (url) {
  const { action, value } = getBrowserEnv()
  switch (action) {
    case Actions.NONE:
    // Special case: BROWSER="none" will prevent opening completely.
      return false
    case Actions.SCRIPT:
      return executeNodeScript(value, url)
    case Actions.BROWSER:
      return startBrowserProcess(value, url)
    default:
      throw new Error('Not implemented.')
  }
}

export {
  openBrowser
}