homebrew.js

import crypto from 'node:crypto'
import fs from 'node:fs'
import path from 'node:path'
import {pipeline} from 'node:stream'
import {fileURLToPath} from 'node:url'
import {promisify} from 'node:util'
import {rimrafSync} from 'rimraf'

import getHerokuS3Bucket from '../utils/get-heroku-s3-bucket.js'
import isStableRelease from '../utils/is-stable-release.js'
import {run, shell, x} from '../utils/script-exec.js'

const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)

const {GITHUB_REF_NAME, GITHUB_REF_TYPE, GITHUB_SHA_SHORT} = process.env
const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'))
const VERSION = packageJson.version

if (!isStableRelease(GITHUB_REF_TYPE, GITHUB_REF_NAME)) {
  console.log('Not on stable release; skipping releasing homebrew')
  // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
  process.exit(0)
}

let HEROKU_S3_BUCKET

async function calculateSHA256(fileName) {
  const hash = crypto.createHash('sha256')
  hash.setEncoding('hex')
  await promisify(pipeline)(fs.createReadStream(fileName), hash)
  return hash.read()
}

const ROOT = path.join(__dirname, 'homebrew')
const TEMPLATES = path.join(ROOT, 'templates')
const fileSuffix = '.tar.xz'
const ARCH_INTEL = 'x64'
const ARCH_ARM = 'arm64'

function downloadFileFromS3(s3Path, fileName, downloadPath) {
  const downloadTo = path.join(downloadPath, fileName)
  const commandStr = `aws s3 cp s3://${HEROKU_S3_BUCKET}/${s3Path}/${fileName} ${downloadTo}`
  return shell(commandStr)
}

async function updateHerokuFormula(brewDir) {
  const templatePath = path.join(TEMPLATES, 'heroku.rb')
  const template = fs.readFileSync(templatePath).toString('utf8')
  const formulaPath = path.join(brewDir, 'Formula', 'heroku.rb')

  const fileNamePrefix = `heroku-v${VERSION}-${GITHUB_SHA_SHORT}`
  const s3KeyPrefix = `versions/${VERSION}/${GITHUB_SHA_SHORT}`
  const urlPrefix = `https://cli-assets.heroku.com/${s3KeyPrefix}`

  const fileNameMacIntel = `${fileNamePrefix}-darwin-${ARCH_INTEL}${fileSuffix}`
  const fileNameMacArm = `${fileNamePrefix}-darwin-${ARCH_ARM}${fileSuffix}`
  const fileNameLinuxIntel = `${fileNamePrefix}-linux-${ARCH_INTEL}${fileSuffix}`
  const fileNameLinuxArm = `${fileNamePrefix}-linux-arm${fileSuffix}`

  // download files from S3 for SHA calc
  await Promise.all([
    downloadFileFromS3(s3KeyPrefix, fileNameMacIntel, __dirname),
    downloadFileFromS3(s3KeyPrefix, fileNameMacArm, __dirname),
    downloadFileFromS3(s3KeyPrefix, fileNameLinuxIntel, __dirname),
    downloadFileFromS3(s3KeyPrefix, fileNameLinuxArm, __dirname),
  ])

  const sha256MacIntel = await calculateSHA256(path.join(__dirname, fileNameMacIntel))
  const sha256MacArm = await calculateSHA256(path.join(__dirname, fileNameMacArm))
  const sha256LinuxIntel = await calculateSHA256(path.join(__dirname, fileNameLinuxIntel))
  const sha256LinuxArm = await calculateSHA256(path.join(__dirname, fileNameLinuxArm))

  const templateReplaced
    = template
      .replace('__CLI_VERSION__', VERSION)

      .replace('__CLI_MAC_INTEL_DOWNLOAD_URL__', `${urlPrefix}/${fileNameMacIntel}`)
      .replace('__CLI_MAC_INTEL_SHA256__', sha256MacIntel)

      .replace('__CLI_MAC_ARM_DOWNLOAD_URL__', `${urlPrefix}/${fileNameMacArm}`)
      .replace('__CLI_MAC_ARM_SHA256__', sha256MacArm)

      .replace('__CLI_LINUX_DOWNLOAD_URL__', `${urlPrefix}/${fileNameLinuxIntel}`)
      .replace('__CLI_LINUX_SHA256__', sha256LinuxIntel)

      .replace('__CLI_LINUX_ARM_DOWNLOAD_URL__', `${urlPrefix}/${fileNameLinuxArm}`)
      .replace('__CLI_LINUX_ARM_SHA256__', sha256LinuxArm)

  fs.writeFileSync(formulaPath, templateReplaced)

  console.log(`done updating heroku Formula in ${formulaPath}`)
}

async function setupGit() {
  const githubSetupPath = path.join(__dirname, '..', 'utils', '_github_setup')
  await x(githubSetupPath, [])
}

async function updateHomebrew() {
  HEROKU_S3_BUCKET = await getHerokuS3Bucket()

  const tmp = path.join(__dirname, 'tmp')
  const homebrewDir = path.join(tmp, 'homebrew-brew')
  fs.mkdirSync(tmp, {recursive: true})
  rimrafSync(homebrewDir)

  await setupGit()

  console.log(`cloning https://github.com/heroku/homebrew-brew to ${homebrewDir}`)
  await x(
    'git',
    [
      'clone',
      'git@github.com:heroku/homebrew-brew.git',
      homebrewDir,
    ],
  )
  console.log(`done cloning heroku/homebrew-brew to ${homebrewDir}`)

  await updateHerokuFormula(homebrewDir)

  // run in git in cloned heroku/homebrew-brew git directory
  const git = async (args, opts = {}) => {
    await x('git', ['-C', homebrewDir, ...args], opts)
  }

  console.log('updating local git...')
  await git(['add', 'Formula'])
  await git(['config', '--local', 'core.pager', 'cat'])
  await git(['diff', '--cached'], {stdio: 'inherit'})
  await git(['commit', '-m', `heroku v${VERSION}`])
  if (process.env.SKIP_GIT_PUSH === undefined) {
    await git(['push', 'origin', 'main'])
  }
}

await run(async () => {
  await updateHomebrew()
})