install.fairie/home/dot_local/bin/executable_install-program

1966 lines
82 KiB
Text
Raw Normal View History

2022-11-29 22:26:34 -08:00
#!/usr/bin/env zx
2022-12-24 20:48:43 -08:00
const execSync = require('child_process').execSync
2022-11-29 22:26:34 -08:00
// Log symbols
const figuresDefault = {
2022-12-24 20:48:43 -08:00
bullet: '●',
circle: '◯',
cross: '✖',
lozenge: '◆',
play: '▶',
pointer: '',
square: '◼',
star: '★',
tick: '✔'
}
const figuresFallback = {
2022-12-24 20:48:43 -08:00
bullet: '■',
circle: '□',
cross: '×',
lozenge: '♦',
play: '►',
pointer: '>',
square: '■',
star: '✶',
tick: '√'
}
function isUnicodeSupported() {
2022-12-24 20:48:43 -08:00
if (process.platform !== 'win32') {
// Linux console (kernel)
2022-12-24 20:48:43 -08:00
return process.env.TERM !== 'linux'
}
return (
Boolean(process.env.CI) ||
// Windows Terminal
Boolean(process.env.WT_SESSION) ||
// ConEmu and cmder
2022-12-24 20:48:43 -08:00
process.env.ConEmuTask === '{cmd::Cmder}' ||
process.env.TERM_PROGRAM === 'vscode' ||
process.env.TERM === 'xterm-256color' ||
process.env.TERM === 'alacritty'
)
}
2022-12-24 20:48:43 -08:00
const figures = isUnicodeSupported() ? figuresDefault : figuresFallback
function log(type, label, msg) {
2022-12-24 20:48:43 -08:00
let icon, message
2023-01-24 09:49:04 -08:00
let fittedLabel = label
while(fittedLabel.length < 14) {
fittedLabel = fittedLabel.length % 2 === 1 ? fittedLabel + ' ' : ' ' + fittedLabel
}
2022-12-24 20:48:43 -08:00
if (type === 'info') {
2023-01-24 09:49:04 -08:00
icon = `${chalk.cyanBright(figures.pointer)} ${chalk.bold.white.bgCyan(' ' + fittedLabel + ' ')}`
2023-01-24 07:54:21 -08:00
message = wrapMessage(msg)
2022-12-24 20:48:43 -08:00
} else if (type === 'star') {
2023-01-24 09:49:04 -08:00
icon = `${chalk.yellow(figures.star)} ${chalk.bold.black.bgYellow(' ' + fittedLabel + ' ')}`
2023-01-24 07:54:21 -08:00
message = wrapMessage(msg)
2022-12-24 20:48:43 -08:00
} else if (type === 'success') {
2023-01-24 09:49:04 -08:00
icon = `${chalk.greenBright(figures.play)} ${chalk.bold.white.bgGreenBright(' ' + fittedLabel + ' ')}`
2023-01-24 07:54:21 -08:00
message = wrapMessage(msg)
2022-12-24 20:48:43 -08:00
} else if (type === 'warn') {
icon = `${chalk.yellowBright(figures.lozenge)} ${chalk.bold.black.bgYellowBright(' WARNING ')}`
2023-01-24 07:54:21 -08:00
message = chalk.yellowBright(wrapMessage(msg))
2022-12-24 20:48:43 -08:00
} else if (type === 'error') {
icon = `${chalk.redBright(figures.cross)} ${chalk.black.bold.bgRedBright(' ERROR ')}`
2023-01-24 07:54:21 -08:00
message = chalk.redBright(wrapMessage(msg))
}
2023-11-13 12:09:23 -08:00
const now = new Date()
const outputMessage = `${icon} ${message} (${now})`
2022-12-24 20:48:43 -08:00
console.log(outputMessage)
}
2023-01-24 07:54:21 -08:00
function locations(substring,string){
var a=[],i=-1;
while((i=string.indexOf(substring,i+1)) >= 0) a.push(i);
return a;
}
function wrapMessage(msg) {
const indexes = locations('`', msg)
2023-01-24 09:59:07 -08:00
if (indexes.length > 3) {
return msg.substring(0, indexes[0]) + chalk.bold.black.bgGray(' ' + msg.substring(indexes[0] + 1, indexes[1] + 1 - indexes[0]) + ' ') + msg.substring(indexes[1] + 1 - indexes[0]) + ' '
2023-01-24 07:54:21 -08:00
} else {
return msg
}
}
2023-01-04 19:45:25 -08:00
function runCommand(spinnerTitle, command) {
2023-07-08 22:50:23 -07:00
// execSync(command.includes('sudo') ? `sudo "$(which gum)" spin --spinner dot --title "${spinnerTitle}" -- ${command}` : `gum spin --spinner dot --title "${spinnerTitle}" -- ${command}`, {
log('info', 'CMD', spinnerTitle)
console.log(command)
2023-07-08 22:50:23 -07:00
execSync(command, {
2023-01-04 19:45:25 -08:00
stdio: 'inherit',
2023-01-31 22:31:07 -08:00
shell: true,
2023-08-30 12:58:51 -07:00
// Timeout of 140m
timeout: 1000 * 60 * 140
2023-01-04 19:45:25 -08:00
})
}
2023-01-04 21:47:56 -08:00
async function runSilentCommand(command) {
execSync(`${command}`, { stdio: 'inherit', shell: true })
}
2023-01-04 19:45:25 -08:00
function fileExists(pathToFile) {
return fs.existsSync(pathToFile)
}
2023-08-03 23:05:20 -07:00
function dirExists(pathToDir) {
return fs.existsSync(pathToDir)
}
2022-12-24 20:48:43 -08:00
let installData
2023-01-03 20:39:23 -08:00
let installOrders = {}
let installMeta = {}
let binLinkRan = false
let chezmoiData = []
2023-02-15 22:53:42 -08:00
let installOrdersPre = []
let installOrdersPost = []
let installOrdersService = []
let installOrdersGroups = []
2023-06-27 19:53:52 -07:00
let installOrdersPorts = []
2023-02-15 22:53:42 -08:00
let installOrdersPlugins = []
let installOrdersBinLink = []
2022-12-24 20:48:43 -08:00
let brewUpdated, osType, osID, snapRefreshed
2022-11-29 22:26:34 -08:00
2023-01-09 04:08:28 -08:00
// Register the OS platform type
const osPlatformData = os.platform()
const osPlatform = osPlatformData === 'win32' ? 'windows' : osPlatformData
2022-11-29 22:26:34 -08:00
// Download the installation map
async function downloadInstallData() {
const response = await fetch('https://github.com/megabyte-labs/install.doctor/raw/master/software.yml')
2022-11-29 22:26:34 -08:00
if (response.ok) {
log('info', 'Catalog Download', `Received ok response from download`)
2022-12-24 20:48:43 -08:00
const text = await response.text()
log('info', 'Catalog Download', `Parsing software.yml`)
return YAML.parse(text, { maxAliasCount: -1 })
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
log('error', 'Catalog Download', `Failed to download the installation map`)
log('info', 'Catalog Download', `Falling back to local version of software.yml`)
const text = fs.readFileSync(process.env.HOME + '/.local/share/chezmoi/software.yml').toString()
log('info', 'Catalog Download', `Parsing local software.yml file`)
return YAML.parse(text, { maxAliasCount: -1 })
2022-11-29 22:26:34 -08:00
}
}
// Download the installation map
async function getChezmoiData() {
const text = fs.readFileSync(process.env.HOME + '/.local/share/chezmoi/home/.chezmoidata.yaml').toString()
return YAML.parse(text, { maxAliasCount: -1 })
}
2022-11-29 22:26:34 -08:00
// Creates the installOrders object which maps package managers to arrays of packages to install
let generateInstallOrderCount = 0
async function generateInstallOrders(pkgsToInstall) {
2022-12-25 10:55:58 -08:00
const installerPreference = await OSTypeInstallerKey()
const preferenceOrder = installData.installerPreference[installerPreference]
2022-12-24 20:48:43 -08:00
const logStage = 'Install Orders'
const packagesToInstall = pkgsToInstall
const softwarePackages = installData.softwarePackages
if (generateInstallOrderCount === 0) {
log('info', logStage, `Installer preference category detected as ${installerPreference}`)
log('info', logStage, `Preference order acquired:`)
2023-02-15 22:14:03 -08:00
console.log('Preference order:', preferenceOrder)
}
generateInstallOrderCount++
log('info', logStage, `New packages discovered for processing: ${pkgsToInstall} (${pkgsToInstall.length} items)`)
pkgFor: for (let pkg of packagesToInstall) {
2022-12-24 20:48:43 -08:00
let packageKey
if (softwarePackages[pkg + ':' + osID]) {
packageKey = pkg + ':' + osID
} else if (softwarePackages[pkg + ':' + osType]) {
packageKey = pkg + ':' + osType
2022-11-29 22:26:34 -08:00
} else if (softwarePackages[pkg]) {
2022-12-24 20:48:43 -08:00
packageKey = pkg
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
log('warn', logStage, `The package \`${pkg}\` was not found in the installation map`)
2023-08-30 14:01:07 -07:00
process.env.DEBUG === 'true' && console.log('softwarePackages:', softwarePackages)
console.log('pkg:', pkg)
2022-12-24 20:48:43 -08:00
continue
2022-11-29 22:26:34 -08:00
}
2023-02-15 19:33:34 -08:00
let comparesRemaining = preferenceOrder.length
2022-11-29 22:26:34 -08:00
for (let preference of preferenceOrder) {
2023-02-15 19:33:34 -08:00
comparesRemaining--
2022-12-24 20:48:43 -08:00
let currentSelector, doubleScoped, scopedPkgManager, scopedSystem, normalCheck
if (
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey][preference + ':' + osID] ||
softwarePackages[packageKey][preference + ':' + osType] ||
softwarePackages[packageKey][preference]
) {
// Handle the _when attribute
2022-12-24 20:48:43 -08:00
currentSelector = 'when'
doubleScoped =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]
scopedPkgManager = softwarePackages[packageKey]['_' + currentSelector + ':' + preference]
scopedSystem =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType]
normalCheck = softwarePackages[packageKey]['_' + currentSelector]
if (doubleScoped) {
try {
2023-06-17 12:13:56 -07:00
await runSilentCommand(doubleScoped)
} catch (e) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID]) {
pref = preference + ':' + osID
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType]) {
pref = preference + ':' + osType
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference]) {
pref = osID + ':' + preference
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]) {
pref = osType + ':' + preference
}
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${pkg} is being skipped because of the _when:${pref} condition`)
2023-06-17 12:13:56 -07:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
}
} else if (scopedPkgManager) {
try {
2023-06-17 12:13:56 -07:00
await runSilentCommand(scopedPkgManager)
} catch (e) {
2022-12-24 20:48:43 -08:00
const pref = preference
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${pkg} is being skipped because of the _when:${pref} condition`)
2023-06-17 12:13:56 -07:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
}
} else if (scopedSystem) {
try {
2023-06-17 12:13:56 -07:00
await runSilentCommand(scopedSystem)
} catch (e) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID]) {
pref = osID
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType]) {
pref = osType
}
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${pkg} is being skipped because of the _when:${pref} condition`)
2023-06-17 12:13:56 -07:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
}
} else if (normalCheck) {
try {
2023-06-17 12:13:56 -07:00
await runSilentCommand(normalCheck)
} catch (e) {
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${pkg} is being skipped because of the _when condition`)
2023-06-17 12:13:56 -07:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
}
}
// Handle the _bin attribute
2022-12-24 20:48:43 -08:00
currentSelector = 'bin'
doubleScoped =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]
scopedPkgManager = softwarePackages[packageKey]['_' + currentSelector + ':' + preference]
scopedSystem =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType]
normalCheck = softwarePackages[packageKey]['_' + currentSelector]
if (doubleScoped) {
2022-12-24 20:48:43 -08:00
const bin =
typeof doubleScoped === 'string'
? which.sync(doubleScoped, { nothrow: true })
: doubleScoped.map((x) => which.sync(x, { nothrow: true })).every((y) => !!y)
if (bin) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID]) {
pref = preference + ':' + osID
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType]) {
pref = preference + ':' + osType
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference]) {
pref = osID + ':' + preference
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]) {
pref = osType + ':' + preference
}
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${bin} already in PATH (via _bin:${pref})`)
2023-01-24 06:41:15 -08:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
} else {
if (preference === 'cask' || preference === 'flatpak') {
installOrdersBinLink.push({ package: packageKey, bin: doubleScoped, preference })
}
}
} else if (scopedPkgManager) {
2022-12-24 20:48:43 -08:00
const bin =
typeof scopedPkgManager === 'string'
? which.sync(scopedPkgManager, { nothrow: true })
: scopedPkgManager.map((x) => which.sync(x, { nothrow: true })).every((y) => !!y)
if (bin) {
2022-12-24 20:48:43 -08:00
const pref = preference
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${bin} already in PATH (via _bin:${pref})`)
2023-01-24 06:41:15 -08:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
} else {
if (preference === 'cask' || preference === 'flatpak') {
installOrdersBinLink.push({ package: packageKey, bin: scopedPkgManager, preference })
}
}
} else if (scopedSystem) {
2022-12-24 20:48:43 -08:00
const bin =
typeof scopedSystem === 'string'
? which.sync(scopedSystem, { nothrow: true })
: scopedSystem.map((x) => which.sync(x, { nothrow: true })).every((y) => !!y)
if (bin) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID]) {
pref = osID
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType]) {
pref = osType
}
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${bin} already in PATH (via _bin:${pref})`)
2023-01-24 06:41:15 -08:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
} else {
if (preference === 'cask' || preference === 'flatpak') {
installOrdersBinLink.push({ package: packageKey, bin: scopedSystem, preference })
}
}
} else if (normalCheck) {
2022-12-24 20:48:43 -08:00
const bin =
typeof normalCheck === 'string'
? which.sync(normalCheck, { nothrow: true })
: normalCheck.map((x) => which.sync(x, { nothrow: true })).every((y) => !!y)
if (bin) {
2023-08-03 23:05:20 -07:00
process.env.DEBUG === 'true' && log('info', 'Filter', `${bin} already in PATH (via _bin)`)
2023-01-24 06:41:15 -08:00
processPluginOrders(pkg)
2022-12-24 20:48:43 -08:00
continue pkgFor
} else {
if (preference === 'cask' || preference === 'flatpak') {
installOrdersBinLink.push({ package: packageKey, bin: normalCheck, preference })
}
}
}
// Handle the _deps attribute
2022-12-24 20:48:43 -08:00
currentSelector = 'deps'
doubleScoped =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]
scopedPkgManager = softwarePackages[packageKey]['_' + currentSelector + ':' + preference]
scopedSystem =
2022-12-24 20:48:43 -08:00
softwarePackages[packageKey]['_' + currentSelector + ':' + osID] ||
softwarePackages[packageKey]['_' + currentSelector + ':' + osType]
normalCheck = softwarePackages[packageKey]['_' + currentSelector]
2023-01-04 20:28:13 -08:00
const dependenciesTag = 'Dependencies'
if (doubleScoped) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osID]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + preference + ':' + osID
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
2022-12-24 20:48:43 -08:00
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + preference + ':' + osType]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + preference + ':' + osType
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
2022-12-24 20:48:43 -08:00
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID + ':' + preference]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + osID + ':' + preference
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
2022-12-24 20:48:43 -08:00
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType + ':' + preference]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + osType + ':' + preference
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
}
} else if (scopedPkgManager) {
2023-01-05 20:21:23 -08:00
const pref = '_deps:' + preference
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
} else if (scopedSystem) {
2022-12-24 20:48:43 -08:00
let pref
if (softwarePackages[packageKey]['_' + currentSelector + ':' + osID]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + osID
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
2022-12-24 20:48:43 -08:00
} else if (softwarePackages[packageKey]['_' + currentSelector + ':' + osType]) {
2023-01-05 20:21:23 -08:00
pref = '_deps:' + osType
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.${pref}`)
await generateInstallOrders(softwarePackages[packageKey][pref])
}
} else if (normalCheck) {
2023-01-04 20:28:13 -08:00
log('info', dependenciesTag, `Installing dependencies for ${packageKey}.deps`)
await generateInstallOrders(softwarePackages[packageKey]['_deps'])
}
2022-12-24 20:48:43 -08:00
if (softwarePackages[packageKey][preference + ':' + osID]) {
await updateInstallMaps(
preference,
softwarePackages[packageKey],
2022-12-24 20:48:43 -08:00
preference + ':' + osID,
pkg,
packageKey,
softwarePackages
2022-12-24 20:48:43 -08:00
)
break
} else if (softwarePackages[packageKey][preference + ':' + osType]) {
await updateInstallMaps(
preference,
softwarePackages[packageKey],
2022-12-24 20:48:43 -08:00
preference + ':' + osType,
pkg,
packageKey,
softwarePackages
2022-12-24 20:48:43 -08:00
)
break
} else if (softwarePackages[packageKey][preference]) {
await updateInstallMaps(
preference,
softwarePackages[packageKey],
preference,
pkg,
packageKey,
softwarePackages
2022-12-24 20:48:43 -08:00
)
break
2023-02-15 19:33:34 -08:00
}
} else {
if (!comparesRemaining) {
2023-02-15 19:33:34 -08:00
log('info', 'No Match', `There was no match found for ${pkg} - it may be an OS-specific package`)
}
2022-11-29 22:26:34 -08:00
}
}
}
if (generateInstallOrderCount === 1) {
return installOrders
} else {
generateInstallOrderCount--
}
2022-11-29 22:26:34 -08:00
}
2023-01-24 06:41:15 -08:00
function processPluginOrders(pkg) {
const pluginMap = chezmoiData && chezmoiData.softwarePlugins && chezmoiData.softwarePlugins[pkg]
2023-01-24 06:41:15 -08:00
if (pluginMap) {
if (pluginMap.cmd && pluginMap.plugins) {
installOrdersPlugins.push({ package: pkg, cmd: pluginMap.cmd, plugins: pluginMap.plugins })
}
}
}
2022-11-29 22:26:34 -08:00
// Update install, pre-hook, and post-hook objects
2022-12-24 20:48:43 -08:00
async function updateInstallMaps(preference, packages, scopedPreference, pkg, packageKey, softwarePackages) {
const preHook = getHook(packages, 'pre', scopedPreference, preference)
2022-11-29 22:26:34 -08:00
if (preHook) {
2023-02-15 22:14:03 -08:00
installOrdersPre = installOrdersPre.concat(typeof preHook === 'string' ? [preHook] : preHook)
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
const postHook = getHook(packages, 'post', scopedPreference, preference)
2022-11-29 22:26:34 -08:00
if (postHook) {
2023-02-15 22:14:03 -08:00
installOrdersPost = installOrdersPost.concat(typeof postHook === 'string' ? [postHook] : postHook)
2022-11-29 22:26:34 -08:00
}
const serviceHook = getHook(packages, 'service', scopedPreference, preference)
2023-08-03 23:05:20 -07:00
const serviceEnabledHook = getHook(packages, 'serviceEnabled', scopedPreference)
if (serviceHook && serviceEnabledHook) {
2023-02-15 22:14:03 -08:00
installOrdersService = installOrdersService.concat(typeof serviceHook === 'string' ? [serviceHook] : serviceHook)
}
const groupsHook = getHook(packages, 'groups', scopedPreference, preference)
if (groupsHook) {
2023-02-15 22:14:03 -08:00
installOrdersGroups = installOrdersGroups.concat(typeof groupsHook === 'string' ? [groupsHook] : groupsHook)
}
2023-06-27 19:53:52 -07:00
const portsHook = getHook(packages, 'ports', scopedPreference, preference)
if (portsHook) {
2023-06-27 22:37:45 -07:00
installOrdersPorts = installOrdersPorts.concat(typeof portsHook === 'string' ? [{
packageKey,
ports: portsHook
}] : {
packageKey,
ports: portsHook})
2023-06-27 19:53:52 -07:00
}
2023-01-24 06:41:15 -08:00
processPluginOrders(pkg)
2022-11-29 22:26:34 -08:00
if (!installOrders[preference]) {
2022-12-24 20:48:43 -08:00
installOrders[preference] = []
2022-11-29 22:26:34 -08:00
}
2023-01-04 20:28:13 -08:00
log('info', 'Match', `Found a match for the package \`${pkg}\` (${packageKey} via ${scopedPreference})`)
2022-12-24 20:48:43 -08:00
const newPackages = packages[scopedPreference]
2023-01-09 04:37:57 -08:00
const newPkgs = typeof newPackages === 'string' ? [ newPackages ] : newPackages
if (typeof newPackages === 'string') {
installMeta[newPackages] = {
preference,
packages,
scopedPreference,
pkg,
packageKey,
softwarePackages
}
} else {
for (const dataKey in newPackages) {
installMeta[newPackages] = {
preference,
packages,
scopedPreference,
pkg,
packageKey,
softwarePackages
}
}
}
2022-12-25 03:28:08 -08:00
if (preference === 'snap' && softwarePackages[pkg]['_snapClassic'] === true) {
if (!installOrders['snap-classic']) {
installOrders['snap-classic'] = []
}
2023-01-09 04:41:48 -08:00
installOrders['snap-classic'] = installOrders['snap-classic'].concat(newPkgs)
} else {
2022-12-24 20:48:43 -08:00
installOrders[preference] = installOrders[preference].concat(newPkgs)
}
2022-11-29 22:26:34 -08:00
}
// Get pre / post install hooks
function getHook(packages, hook, scopedPreference, preference) {
2022-12-24 20:48:43 -08:00
const hookLabel = '_' + hook + ':'
2022-11-29 22:26:34 -08:00
if (packages[hookLabel + scopedPreference]) {
2022-12-24 20:48:43 -08:00
return packages[hookLabel + scopedPreference]
2022-11-29 22:26:34 -08:00
} else if (packages[hookLabel + preference]) {
2022-12-24 20:48:43 -08:00
return packages[hookLabel + preference]
2022-11-29 22:26:34 -08:00
} else if (packages[hookLabel + osID]) {
2022-12-24 20:48:43 -08:00
return packages
2022-11-29 22:26:34 -08:00
} else if (packages[hookLabel + osType]) {
2022-12-24 20:48:43 -08:00
return packages[hookLabel + osType]
} else if (packages['_' + hook]) {
return packages['_' + hook]
2022-11-29 22:26:34 -08:00
}
}
// Acquire OS type installer key (for the installerPreference data key)
async function OSTypeInstallerKey() {
2022-12-24 08:57:06 -08:00
try {
2022-12-24 20:48:43 -08:00
const apt = which.sync('apt-get', { nothrow: true })
const dnf = which.sync('dnf', { nothrow: true })
const freebsdPkg = which.sync('pkg', { nothrow: true })
const freebsdVersion = which.sync('freebsd-version', { nothrow: true })
const pacman = which.sync('pacman', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
const zypper = which.sync('zypper', { nothrow: true })
2022-12-24 08:57:06 -08:00
if (apt) {
2023-08-03 23:05:20 -07:00
return dirExists('/etc/ubuntu-advantage') ? 'ubuntu' : 'apt'
2022-12-24 08:57:06 -08:00
} else if (dnf || yum) {
2022-12-24 20:48:43 -08:00
return 'dnf'
2022-12-24 08:57:06 -08:00
} else if (pacman) {
2022-12-24 20:48:43 -08:00
return 'pacman'
2022-12-24 08:57:06 -08:00
} else if (zypper) {
2022-12-24 20:48:43 -08:00
return 'zypper'
2022-12-24 08:57:06 -08:00
} else if (freebsdPkg && freebsdVersion) {
2022-12-24 20:48:43 -08:00
return 'freebsd'
2022-12-24 08:57:06 -08:00
} else {
2023-08-03 23:05:20 -07:00
return dirExists('/Applications') && dirExists('/Library') ? 'darwin' : 'windows'
2022-11-29 22:26:34 -08:00
}
2022-12-24 08:57:06 -08:00
} catch (e) {
2022-12-24 20:48:43 -08:00
log('error', 'OS Detection', 'There was an error determining the type of operating system')
2022-12-24 08:57:06 -08:00
console.error(e)
2022-11-29 22:26:34 -08:00
}
}
// Acquire OS type
async function OSType() {
2023-08-03 23:05:20 -07:00
return dirExists('/Applications') && dirExists('/Library') ? 'darwin' : (fileExists('/etc/os-release') ? 'linux' : 'windows')
2022-11-29 22:26:34 -08:00
}
// Acquire release ID (for Linux)
async function releaseID() {
const ID = await $`
if [ -f /etc/os-release ]; then
. /etc/os-release
echo -n $ID
fi
2022-12-24 20:48:43 -08:00
`
return ID.stdout
2022-11-29 22:26:34 -08:00
}
// Post-install hook
async function afterInstall(packageManager) {
2022-12-24 20:48:43 -08:00
const logStage = 'Post-Install Package Manager'
if (packageManager === 'appimage') {
} else if (packageManager === 'ansible') {
log('info', logStage, `Ensuring temporary passwordless sudo privileges used by Ansible are removed`)
const gsed = which.sync('gsed', { nothrow: true })
if (gsed) {
await $`sudo gsed -i '/# TEMPORARY FOR ANSIBLE INSTALL DOCTOR/d' /etc/sudoers`
} else {
await $`sudo sed -i '/# TEMPORARY FOR ANSIBLE INSTALL DOCTOR/d' /etc/sudoers`
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'apk') {
} else if (packageManager === 'apt') {
try {
2023-01-04 20:05:31 -08:00
runCommand('Running apt-get autoclean', `sudo apt-get autoclean`)
runCommand('Running apt-get autoremove', `sudo apt-get -y autoremove`)
} catch (e) {
log('error', logStage, 'Error cleaning up apt-get')
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'basher') {
} else if (packageManager === 'binary') {
} else if (packageManager === 'brew' || packageManager === 'cask') {
log('info', logStage, `Ensuring Homebrew cleanup is run`)
await $`brew cleanup`
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'cargo') {
} else if (packageManager === 'choco') {
} else if (packageManager === 'crew') {
} else if (packageManager === 'dnf') {
} else if (packageManager === 'flatpak') {
} else if (packageManager === 'gem') {
} else if (packageManager === 'go') {
} else if (packageManager === 'nix') {
} else if (packageManager === 'npm') {
} else if (packageManager === 'pacman') {
} else if (packageManager === 'pipx') {
} else if (packageManager === 'pkg') {
} else if (packageManager === 'port') {
} else if (packageManager === 'scoop') {
} else if (packageManager === 'script') {
} else if (packageManager === 'snap') {
} else if (packageManager === 'whalebrew') {
} else if (packageManager === 'winget') {
} else if (packageManager === 'yay') {
} else if (packageManager === 'zypper') {
2022-11-29 22:26:34 -08:00
}
}
async function ensurePackage(dep) {
const target = which.sync(dep, { nothrow: true })
if (!target) {
if (osType === 'linux') {
2022-12-24 20:48:43 -08:00
const apk = which.sync('apk', { nothrow: true })
const apt = which.sync('apt-get', { nothrow: true })
2022-12-24 20:48:43 -08:00
const dnf = which.sync('dnf', { nothrow: true })
2023-01-03 19:52:32 -08:00
const pkg = which.sync('pkg', { nothrow: true })
2022-12-24 20:48:43 -08:00
const yum = which.sync('yum', { nothrow: true })
const pacman = which.sync('pacman', { nothrow: true })
const zypper = which.sync('zypper', { nothrow: true })
if (apk) {
await $`sudo apk add ${dep}`
} else if (apt) {
2022-12-25 11:07:19 -08:00
if (updateDone['apt-get'] !== true) {
await beforeInstall('apt-get')
}
2023-01-03 19:52:32 -08:00
try {
log('info', 'apt-get Installation', `Checking if ${dep} is already installed`)
2023-01-09 04:30:16 -08:00
runCommand(
`Checking if ${dep} is already installed via apt-get`,
`dpkg -l ${dep} | grep -E '^ii' > /dev/null`
)
2023-01-04 20:05:31 -08:00
log('info', 'Filter', `${pkg} already installed via apt-get`)
2023-01-03 19:52:32 -08:00
} catch (e) {
2023-01-09 04:30:16 -08:00
runCommand(
`Installing ${dep} via apt-get`,
`sudo apt-get -o DPkg::Options::=--force-confdef install -y ${dep}`
)
2023-01-04 20:05:31 -08:00
log('success', 'Install', `Successfully installed ${pkg} via apt-get`)
2023-01-03 19:52:32 -08:00
}
} else if (dnf) {
2022-12-25 11:07:19 -08:00
if (updateDone['dnf'] !== true) {
await beforeInstall('dnf')
}
2023-01-03 19:52:32 -08:00
try {
log('info', 'dnf Installation', `Checking if ${dep} is already installed`)
await $`rpm -qa | grep '$'"${dep}-" > /dev/null`
2023-01-03 19:52:32 -08:00
} catch (e) {
log('info', 'dnf Installation', `Installing ${dep} since it is not already present on the system`)
await $`sudo dnf install -y ${dep}`
}
} else if (yum) {
2022-12-25 11:07:19 -08:00
if (updateDone['yum'] !== true) {
await beforeInstall('yum')
}
2023-01-03 19:52:32 -08:00
try {
log('info', 'YUM Installation', `Checking if ${dep} is already installed`)
await $`rpm -qa | grep '$'"${dep}-" > /dev/null`
2023-01-03 19:52:32 -08:00
} catch (e) {
log('info', 'YUM Installation', `Installing ${dep} since it is not already present on the system`)
await $`sudo yum install -y ${dep}`
}
} else if (pacman) {
2022-12-25 11:07:19 -08:00
if (updateDone['pacman'] !== true) {
await beforeInstall('pacman')
}
2023-01-03 19:52:32 -08:00
try {
log('info', 'Pacman Installation', `Checking if ${dep} is already installed`)
await $`pacman -Qs ${dep}`
} catch (e) {
log('info', 'Pacman Installation', `Installing ${dep} since it is not already present on the system`)
await $`sudo pacman -Sy ${dep}`
}
} else if (zypper) {
2022-12-25 11:07:19 -08:00
if (updateDone['zypper'] !== true) {
await beforeInstall('zypper')
}
2023-01-03 19:52:32 -08:00
try {
log('info', 'Zypper Installation', `Checking if ${dep} is already installed`)
await $`rpm -qa | grep '$'"${dep}-" > /dev/null`
2023-01-03 19:52:32 -08:00
} catch (e) {
log('info', 'Zypper Installation', `Installing ${dep} since it is not already present on the system`)
await $`sudo zypper install -y ${dep}`
}
} else if (pkg) {
if (updateDone['pkg'] !== true) {
await beforeInstall('pkg')
}
try {
log('info', 'pkg Installation', `Checking if ${dep} is already installed`)
await $`pkg info -Ix ${dep} > /dev/null`
} catch (e) {
log('info', 'pkg Installation', `Installing ${dep} since it is not already present on the system`)
await $`sudo pkg install -y ${dep}`
}
}
} else if (osType === 'darwin') {
if (updateDone['brew'] !== true) {
await beforeInstall('brew')
}
await $`brew install --quiet ${dep}`
} else if (osType === 'windows') {
if (updateDone['choco'] !== true) {
await beforeInstall('choco')
}
await `choco install -y ${dep}`
}
}
}
2022-11-29 22:26:34 -08:00
// Pre-install hook
const updateDone = {}
2022-11-29 22:26:34 -08:00
async function beforeInstall(packageManager) {
updateDone[packageManager] = true
2022-12-24 20:48:43 -08:00
const logStage = 'Pre-Install Package Manager'
if (packageManager === 'appimage') {
2023-01-09 04:30:16 -08:00
if (!fileExists(`${process.env.HOME}/Applications`)) {
runSilentCommand(`mkdir -p "${process.env.HOME}/Applications"`)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'ansible') {
log('info', logStage, `Temporarily enabling passwordless sudo for Ansible role installations`)
await $`echo "$(whoami) ALL=(ALL:ALL) NOPASSWD: ALL # TEMPORARY FOR ANSIBLE INSTALL DOCTOR" | sudo tee -a /etc/sudoers`
log('info', logStage, 'Running Ansible setup task so facts are cached')
const unbuffer = which.sync('unbuffer', { nothrow: true })
let unbufferPrefix = ''
if (unbuffer) {
unbufferPrefix = 'unbuffer'
}
2023-01-09 04:08:28 -08:00
if (osPlatform === 'darwin' || osPlatform === 'linux' || osPlatform === 'windows') {
2023-01-11 22:53:14 -08:00
const capitalOsPlatform = osPlatform.charAt(0).toUpperCase() + osPlatform.slice(1)
await $`ANSIBLE_CONFIG=${process.env.HOME}/.local/share/ansible/ansible.cfg ${unbufferPrefix} ansible 127.0.0.1 -e '{ ansible_connection: "local", ansible_become_user: "${process.env.USER}", ansible_user: "${process.env.USER}", ansible_family: "${capitalOsPlatform}", install_homebrew: False }' -m setup`
2023-01-09 04:08:28 -08:00
} else {
log('warn', 'Ansible', 'Unsupported platform - ' + osPlatform)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'apk') {
await $`sudo apk update`
} else if (packageManager === 'apt') {
2023-01-04 23:24:36 -08:00
runCommand('Running apt-get update / upgrade', `sudo apt-get update && sudo apt-get upgrade -y`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'basher') {
} else if (packageManager === 'binary') {
} else if (packageManager === 'brew' || packageManager === 'cask') {
if (!brewUpdated) {
brewUpdated = true
try {
2023-07-10 23:58:10 -07:00
runCommand('Running brew update / upgrade', `brew update && brew upgrade --cask && brew upgrade`)
} catch (e) {
2023-05-29 19:28:25 -07:00
console.log(e)
log('error', 'Homebrew', 'Failed running brew update / upgrade')
log('info', 'Homebrew', 'Running brew tap --repair and trying again')
try {
2023-07-18 10:58:34 -07:00
runCommand('Repairing taps and retrying brew update / upgrade', 'sudo rm -rf $(brew --cache) && brew tap --repair && brew update && brew upgrade --cask --greedy && brew upgrade --force --greedy')
2023-05-29 19:28:25 -07:00
} catch (e) {
console.log(e)
log('error', 'Homebrew', 'Failed both attempts to run brew update / upgrade')
}
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'cargo') {
} else if (packageManager === 'choco') {
} else if (packageManager === 'crew') {
await $`crew update`
} else if (packageManager === 'dnf') {
const dnf = which.sync('dnf', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
if (dnf) {
runCommand('Running dnf update', `sudo dnf update -y`)
} else if (yum) {
runCommand('Running yum update', `sudo yum update -y`)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'flatpak') {
// TODO - figure out why CentOS is failing to update
// and then switch command below for `sudo flatpak update -y`
2023-02-01 13:15:35 -08:00
runCommand('Running flatpak update', `. /etc/os-release; if [ "$ID" != "centos" ]; then sudo flatpak update -y; else echo "Skipping Flatpak update on CentOS"; fi`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'gem') {
} else if (packageManager === 'go') {
} else if (packageManager === 'nix') {
runCommand('Running nix-channel --update', `nix-channel --update`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'npm') {
} else if (packageManager === 'pacman') {
runCommand('Running pacman update', `sudo pacman -Syu`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'pipx') {
} else if (packageManager === 'pkg') {
await $`sudo pkg upgrade`
} else if (packageManager === 'port') {
const port = which.sync('port', { nothrow: true })
if (port) {
runCommand('Running port sync', `sudo port sync`)
} else {
2022-12-24 20:48:43 -08:00
log('error', 'Port Not Installed', 'Skipping sudo port sync step because port is not installed')
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'scoop') {
runCommand('Running scoop update', `scoop update`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'snap' || packageManager === 'snap-classic') {
if (!snapRefreshed) {
snapRefreshed = true
runCommand('Ensuring snap is refreshed', `sudo snap refresh`)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'whalebrew') {
if (osType === 'darwin') {
const docker = which.sync('docker', { nothrow: true })
if (!docker) {
await $`brew install --cask --no-quarantine --quiet docker`
}
try {
await $`sudo -c 'docker run --rm hello-world' - ${process.env.USER}`
} catch (e) {
2022-12-24 20:48:43 -08:00
log('warn', logStage, `The command \`docker run --rm hello-world\` failed`)
try {
log(
2022-12-24 20:48:43 -08:00
'info',
logStage,
2022-12-24 20:48:43 -08:00
'Attempting to open `/Applications/Docker.app` (Docker Desktop for macOS). This should take about 30 seconds.'
)
2023-11-06 01:56:49 -08:00
const promises = [$`test -d /Applications/Docker.app`, $`open --background -a Docker --args --accept-license --unattended`]
2022-12-24 20:48:43 -08:00
await Promise.all(promises)
const gum = which.sync('gum', { nothrow: true })
if (gum) {
2022-12-24 20:48:43 -08:00
execSync('gum spin --spinner dot --title "Waiting for Docker Desktop to start up.." -- sleep 30', {
stdio: 'inherit',
shell: true
})
} else {
2022-12-24 20:48:43 -08:00
await $`sleep 30`
}
} catch (e) {
2022-12-24 20:48:43 -08:00
log('warn', logStage, `Docker Desktop appears to not be installed!`)
}
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'winget') {
runCommand('Running winget source update', `winget source update`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'yay') {
} else if (packageManager === 'zypper') {
runCommand('Running zypper update', `sudo zypper update`)
2022-11-29 22:26:34 -08:00
}
}
async function ensureInstalled(bin, callback) {
2022-12-24 20:48:43 -08:00
const logStage = 'Package Manager Install'
const installed = which.sync(bin, { nothrow: true })
2022-11-29 22:26:34 -08:00
if (installed) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`${bin}\` is available`)
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
log('warn', logStage, `\`${bin}\` is not installed!`)
2022-11-29 22:26:34 -08:00
if (callback) {
2022-12-24 20:48:43 -08:00
await callback
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
log('error', logStage, `There does not appear to be an installation method available for \`${bin}\``)
2022-11-29 22:26:34 -08:00
}
}
}
async function ensurePackageManagerAnsible() {
await $`pipx install ansible-core`
2022-12-25 01:38:17 -08:00
if (osType === 'darwin') {
await $`pipx inject ansible-core PyObjC PyObjC-core`
2022-12-25 01:38:17 -08:00
}
await $`pipx inject ansible-core docker lxml netaddr pexpect python-vagrant pywinrm requests-credssp watchdog`
2023-08-08 23:12:46 -07:00
await $`mkdir -p "$HOME/.cache/megabyte-labs"`
await $`touch "$HOME/.cache/megabyte-labs/ansible-installed"`
2022-12-24 20:48:43 -08:00
log('info', 'Package Manager Install', `Ansible and its supporting packages are now installed via pipx`)
}
2022-11-29 22:26:34 -08:00
// Ensure the package manager is available
2022-12-24 20:48:43 -08:00
let packageManagerInstalled = {}
2022-11-29 22:26:34 -08:00
async function ensurePackageManager(packageManager) {
2023-01-04 20:29:51 -08:00
const logStage = 'Pre-Reqs'
2022-12-24 20:48:43 -08:00
log('info', logStage, `Ensuring \`${packageManager}\` is set up`)
2022-11-29 22:26:34 -08:00
if (packageManagerInstalled[packageManager]) {
2022-12-24 20:48:43 -08:00
return
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
packageManagerInstalled[packageManager] = true
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
if (packageManager === 'ansible') {
await ensurePackageManager('pipx')
2022-11-29 22:26:34 -08:00
}
if (
2022-12-24 20:48:43 -08:00
packageManager === 'gem' ||
packageManager === 'go' ||
packageManager === 'npm' ||
packageManager === 'pipx' ||
packageManager === 'whalebrew'
2022-11-29 22:26:34 -08:00
) {
2022-12-24 20:48:43 -08:00
await ensurePackageManager('brew')
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
if (packageManager === 'appimage') {
const zap = which.sync('zap', { nothrow: true })
if (!zap) {
2022-12-24 20:48:43 -08:00
log('info', 'Zap Installation', 'Installing Zap to handle AppImage installation')
await ensurePackage('curl')
2023-01-03 22:54:18 -08:00
await $`sudo curl -sSL --output /usr/local/bin/zap https://github.com/srevinsaju/zap/releases/download/continuous/zap-amd64`
2023-01-04 18:58:31 -08:00
await $`sudo chmod +x /usr/local/bin/zap`
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'ansible') {
try {
2023-08-08 23:12:46 -07:00
await $`test -f "$HOME/.cache/megabyte-labs/ansible-installed"`
2022-12-24 20:48:43 -08:00
const ansible = which.sync('ansible', { nothrow: true })
if (ansible) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`ansible\` and its supporting packages appear to be installed`)
} else {
2022-12-24 20:48:43 -08:00
await ensurePackageManagerAnsible()
}
} catch (e) {
2022-12-24 20:48:43 -08:00
await ensurePackageManagerAnsible()
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'apk') {
await ensureInstalled('apk', false)
} else if (packageManager === 'apt') {
await ensureInstalled('apt', false)
} else if (packageManager === 'basher') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'basher',
$`
2022-11-29 22:26:34 -08:00
# TODO
echo "Bash script that installs basher here"
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'binary') {
await ensurePackage('curl')
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'bpkg') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'bpkg',
$`
2022-11-29 22:26:34 -08:00
# TODO
echo "Bash script that installs bpkg here"
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'brew' || packageManager === 'cask') {
const brew = which.sync('brew', { nothrow: true })
if (!brew) {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'brew',
$`
if command -v sudo > /dev/null && sudo -n true; then
echo | bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
else
log('info', logStage, 'Homebrew is not installed. Password may be required.')
bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" || BREW_EXIT_CODE="$?"
if [ -n "$BREW_EXIT_CODE" ]; then
if command -v brew > /dev/null; then
log('warn', logStage, 'Homebrew was installed but part of the installation failed. Attempting to fix..')
BREW_DIRS="share/man share/doc share/zsh/site-functions etc/bash_completion.d"
for BREW_DIR in $BREW_DIRS; do
if [ -d "$(brew --prefix)/$BREW_DIR" ]; then
sudo chown -R "$(whoami)" "$(brew --prefix)/$BREW_DIR"
fi
done
brew update --force --quiet
fi
2022-11-29 22:26:34 -08:00
fi
fi
`
2022-12-24 20:48:43 -08:00
)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'cargo') {
const cargo = which.sync('cargo', { nothrow: true })
if (!cargo) {
if (osType === 'darwin') {
2023-06-13 23:20:56 -07:00
const rustup = which.sync('rustup-init', { nothrow: true })
if (!rustup) {
await $`brew install --quiet rustup`
2023-06-13 23:20:56 -07:00
}
await $`rustup-init -y`
} else if (osType === 'windows') {
} else {
await ensurePackage('cargo')
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'choco') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'choco',
$`
2022-11-29 22:26:34 -08:00
powershell "Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))"
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'crew') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'crew',
$`
2022-11-29 22:26:34 -08:00
# TODO Bash script that installs crew here
# Source: https://github.com/chromebrew/chromebrew
curl -Ls git.io/vddgY | bash
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'dnf') {
const dnf = which.sync('dnf', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
2022-11-29 22:26:34 -08:00
if (dnf) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`dnf\` is available`)
2022-11-29 22:26:34 -08:00
} else if (yum) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`yum\` is available`)
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
log('error', logStage, `Both \`dnf\` and \`yum\` are not available`)
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'flatpak') {
const flatpak = which.sync('flatpak', { nothrow: true })
2022-11-29 22:26:34 -08:00
if (flatpak) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`flatpak\` is available`)
2022-11-29 22:26:34 -08:00
} else {
2022-12-24 20:48:43 -08:00
const apk = which.sync('apk', { nothrow: true })
const apt = which.sync('apt-get', { nothrow: true })
2022-12-24 20:48:43 -08:00
const dnf = which.sync('dnf', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
const pacman = which.sync('pacman', { nothrow: true })
const zypper = which.sync('zypper', { nothrow: true })
2022-11-29 22:26:34 -08:00
if (apk) {
2023-01-04 19:45:25 -08:00
runCommand('Installing flatpak via apk', 'sudo apk add flatpak')
} else if (apt) {
2023-01-04 19:45:25 -08:00
runCommand('Installing flatpak via apt-get', 'sudo apt-get install -y flatpak')
if (fileExists('/usr/bin/gnome-shell')) {
2023-01-09 04:30:16 -08:00
runCommand(
'Installing gnome-software-plugin-flatpak via apt-get',
'sudo apt-get install -y gnome-software-plugin-flatpak'
)
2023-01-04 19:45:25 -08:00
}
if (fileExists('/usr/bin/plasmashell')) {
runCommand('Installing plasmashell via apt-get', 'sudo apt-get install -y plasmashell')
}
} else if (dnf) {
2022-12-24 20:48:43 -08:00
await $`sudo dnf install -y flatpak`
} else if (yum) {
2022-12-24 20:48:43 -08:00
await $`sudo yum install -y flatpak`
2022-11-29 22:26:34 -08:00
} else if (pacman) {
2022-12-24 20:48:43 -08:00
await $`sudo pacman -Sy flatpak`
2022-11-29 22:26:34 -08:00
} else if (zypper) {
2022-12-24 20:48:43 -08:00
await $`sudo zypper install -y flatpak`
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`flatpak\` was installed. It may require a reboot to function correctly.`)
2022-11-29 22:26:34 -08:00
}
2023-01-24 22:05:08 -08:00
const flatpakPost = which.sync('flatpak', { nothrow: true })
if (flatpakPost) {
await $`sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo`
} else {
log('error', logStage, `\`flatpak\` failed to install!`)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'gem') {
2023-01-03 23:05:17 -08:00
const gem = which.sync('gem', { nothrow: true })
if (!gem) {
await ensureInstalled('gem', $`brew install --quiet ruby`)
2023-01-03 23:05:17 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'go') {
2023-01-03 23:05:17 -08:00
const go = which.sync('go', { nothrow: true })
if (!go) {
await ensureInstalled('go', $`brew install --quiet go`)
2023-01-03 23:05:17 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'nix') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'nix',
$`
2022-11-29 22:26:34 -08:00
if [ -d /Applications ] && [ -d /Library ]; then
sh <(curl -L https://nixos.org/nix/install)
else
sh <(curl -L https://nixos.org/nix/install) --daemon
fi
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'npm') {
2022-12-25 11:07:19 -08:00
const npm = which.sync('npm', { nothrow: true })
const node = which.sync('node', { nothrow: true })
const volta = which.sync('volta', { nothrow: true })
2022-11-29 22:26:34 -08:00
if (npm && node && volta) {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`npm\`, \`node\`, and \`volta\` are available`)
2022-11-29 22:26:34 -08:00
} else {
if (!volta) {
await $`brew install --quiet volta`
2022-11-29 22:26:34 -08:00
}
await $`
2023-07-17 10:41:49 -07:00
export VOLTA_HOME="\${XDG_DATA_HOME:-$HOME/.local/share}/volta"
2022-11-29 22:26:34 -08:00
export PATH="$VOLTA_HOME/bin:$PATH"
2023-07-17 10:41:49 -07:00
volta setup
2022-11-29 22:26:34 -08:00
volta install node
2022-12-24 20:48:43 -08:00
`
2022-11-29 22:26:34 -08:00
}
2022-12-25 02:19:44 -08:00
log('info', logStage, 'Ensuring Volt has Node.js runtime available')
2023-07-17 10:41:49 -07:00
await $`export VOLTA_HOME="\${XDG_DATA_HOME:-$HOME/.local/share}/volta" && export PATH="$VOLTA_HOME/bin:$PATH" && if ! volta list 2>&1 | grep 'runtime node' > /dev/null; then volta install node; fi`
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'pacman') {
await ensureInstalled('pacman', false)
} else if (packageManager === 'pipx') {
2022-12-25 11:07:19 -08:00
const pipx = which.sync('pipx', { nothrow: true })
if (!pipx) {
await ensureInstalled('pipx', $`brew install --quiet pipx`)
2022-12-25 11:07:19 -08:00
await $`pipx ensurepath`
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'pkg') {
await ensureInstalled('pkg', false)
} else if (packageManager === 'port') {
const port = which.sync('port', { nothrow: true })
if (!port) {
log('info', logStage, `Installing ${packageManager}`)
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'port',
$`
sudo mkdir -p /opt/mports
cd /opt/mports
sudo rm -rf macports-base
sudo git clone https://github.com/macports/macports-base.git
cd macports-base
sudo git checkout v2.8.0
sudo bash --noprofile --norc -c './configure --enable-readline && make && make install && make distclean'
sudo port selfupdate
`
2022-12-24 20:48:43 -08:00
)
log('info', logStage, `${packageManager} is now installed`)
} else {
2022-12-24 20:48:43 -08:00
log('info', logStage, `\`port\` is available`)
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'scoop') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'scoop',
$`
2022-11-29 22:26:34 -08:00
powershell 'Set-ExecutionPolicy RemoteSigned -Scope CurrentUser'
powershell 'irm get.scoop.sh | iex
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'snap') {
const apk = which.sync('apk', { nothrow: true })
const apt = which.sync('apt-get', { nothrow: true })
const dnf = which.sync('dnf', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
const pacman = which.sync('pacman', { nothrow: true })
const zypper = which.sync('zypper', { nothrow: true })
if (apt) {
2023-01-04 20:16:11 -08:00
if (fileExists('/etc/apt/preferences.d/nosnap.pref')) {
$`sudo mv /etc/apt/preferences.d/nosnap.pref /etc/apt/nosnap.pref.bak`
}
runCommand('Ensuring snapd is installed', `sudo apt-get install -y snapd`)
// TODO Following may be required on Kali -> https://snapcraft.io/docs/installing-snap-on-kali
// systemctl enable --now snapd apparmor
runCommand('Enabling snapd service', `sudo systemctl enable snapd`)
runCommand('Starting snapd service', `sudo systemctl start snapd`)
} else if (dnf) {
2023-01-04 20:16:11 -08:00
runCommand('Ensuring snapd is installed', `sudo dnf install -y snapd`)
if (!fileExists('/snap')) {
await $`sudo ln -s /var/lib/snapd/snap /snap`
}
runCommand('Enabling snapd service', `sudo systemctl enable snapd`)
runCommand('Starting snapd service', `sudo systemctl start snapd`)
} else if (yum) {
2023-01-04 20:18:00 -08:00
runCommand('Ensuring snapd is installed', 'sudo yum install -y snapd')
2023-01-04 20:16:11 -08:00
await $`sudo systemctl enable --now snapd.socket`
if (!fileExists('/snap')) {
$`sudo ln -s /var/lib/snapd/snap /snap`
}
} else if (pacman) {
2023-01-04 20:16:11 -08:00
$`if [ -f /etc/arch-release ]; then sudo git clone https://aur.archlinux.org/snapd.git /usr/local/src/snapd && cd /usr/local/src/snapd && sudo makepkg -si; else sudo pacman -S snapd && sudo systemctl enable --now snapd.socket && if [ ! -d /snap ]; then sudo ln -s /var/lib/snapd/snap /snap; fi; fi`
} else if (zypper) {
// TODO See https://snapcraft.io/docs/installing-snap-on-opensuse
await $`
2022-11-29 22:26:34 -08:00
echo "TODO - Bash script that installs snap w/ zypper"
2022-12-24 20:48:43 -08:00
`
}
2022-12-24 20:48:43 -08:00
const snap = which.sync('snap', { nothrow: true })
if (snap) {
2023-01-24 17:01:33 -08:00
runCommand('Check info for core snap package', `sudo snap info core`)
2023-08-17 21:08:01 -07:00
// Required: https://snapcraft.io/docs/troubleshooting#heading--early
runCommand('Ensuring snap is seeded', `sudo snap wait system seed.loaded`)
2023-01-04 19:58:08 -08:00
runCommand('Ensuring snap core is installed', `sudo snap install core`)
} else {
2022-12-24 20:48:43 -08:00
log('warn', logStage, 'Snap installation sequence completed but the snap bin is still not available')
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'script') {
} else if (packageManager === 'whalebrew') {
await ensureInstalled('whalebrew', $`brew install --quiet whalebrew`)
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'winget') {
await ensureInstalled(
2022-12-24 20:48:43 -08:00
'winget',
$`
2022-11-29 22:26:34 -08:00
echo "TODO - Script that installs winget here"
`
2022-12-24 20:48:43 -08:00
)
} else if (packageManager === 'yay') {
const yay = which.sync('yay', { nothrow: true })
await $`sudo pacman -S --needed base-devel git`
2022-11-29 22:26:34 -08:00
await $`
if [ -d /usr/local/src ]; then
git clone https://aur.archlinux.org/yay.git /usr/local/src/yay
cd /usr/local/src/yay
makepkg -si
fi
2022-12-24 20:48:43 -08:00
`
} else if (packageManager === 'zypper') {
await ensureInstalled('zypper', false)
2022-11-29 22:26:34 -08:00
}
}
// Installs a list of packages via the specified package manager
async function installPackageList(packageManager, packages) {
2022-12-24 20:48:43 -08:00
const logStage = 'Package Install'
2022-11-29 22:26:34 -08:00
try {
2022-12-24 20:48:43 -08:00
if (packageManager === 'appimage') {
for (let pkg of packages) {
try {
if (pkg.substring(0, 4) === 'http') {
2022-12-24 20:48:43 -08:00
log('info', 'AppImage Install', `Installing ${pkg} from its URL`)
2023-01-24 16:51:15 -08:00
runCommand('Installing ${pkg} via zap', `zap install --select-first -q --from ${pkg}`)
} else if ((pkg.match(/\//g) || []).length === 1) {
2022-12-24 20:48:43 -08:00
log('info', 'AppImage Install', `Installing ${pkg} from a GitHub Release`)
2023-01-24 16:51:15 -08:00
runCommand('Installing ${pkg} via zap', `zap install --select-first -q --github --from ${pkg}`)
} else {
2022-12-24 20:48:43 -08:00
log('info', 'AppImage Install', `Installing ${pkg} using the AppImage Catalog`)
2023-01-24 16:51:15 -08:00
runCommand('Installing ${pkg} via zap', `zap install --select-first -q ${pkg}`)
}
2023-01-04 20:57:52 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error using Zap to install ${pkg}`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
log('warn', 'Install', 'Zap installs might fail - this is expected. Waiting on fixes to Zap upstream project')
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'ansible') {
for (let pkg of packages) {
try {
const unbuffer = which.sync('unbuffer', { nothrow: true })
let unbufferPrefix = ''
if (unbuffer) {
unbufferPrefix = 'unbuffer'
}
const verboseMode = process.env.DEBUG_MODE === 'true' ? 'vv' : ''
2023-01-09 04:46:44 -08:00
if (osPlatform === 'darwin' || osPlatform === 'linux' || osPlatform === 'windows') {
2023-01-12 12:19:28 -08:00
const capitalOsPlatform = osPlatform.charAt(0).toUpperCase() + osPlatform.slice(1)
await $`ANSIBLE_CONFIG=${process.env.HOME}/.local/share/ansible/ansible.cfg ansible 127.0.0.1 -v${verboseMode} -e '{ ansible_connection: "local", ansible_become_user: "root", ansible_user: "${process.env.USER}", ansible_family: "${capitalOsPlatform}", install_homebrew: False }' -m include_role -a name=${pkg}`
2023-01-09 04:46:44 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} else {
log('warn', 'Ansible', 'Unsupported platform - ' + osPlatform)
}
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with Ansible`)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'apk') {
for (let pkg of packages) {
try {
2023-01-04 20:05:31 -08:00
runCommand('Installing ${pkg} via apk', `sudo apk add ${pkg}`)
2023-01-04 20:57:52 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with apk`)
2023-01-08 21:30:07 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'apt') {
for (let pkg of packages) {
try {
2023-01-09 04:30:16 -08:00
runCommand(
`Installing ${pkg} via ${packageManager}`,
`sudo apt-get -o DPkg::Options::=--force-confdef install -y ${pkg}`
)
2023-01-04 20:57:52 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with apt-get`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'basher') {
for (let pkg of packages) {
try {
2022-12-24 20:48:43 -08:00
await $`basher install ${pkg}`
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with basher`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'binary') {
for (let pkg of packages) {
try {
2023-01-09 04:30:16 -08:00
const bins = installData.softwarePackages.filter((x) => x.appimage === pkg)
if (bins && bins[0]) {
const binName = bins[0]['_bin']
await $`TMP="$(mktemp)" && curl -sSL ${pkg} > "$TMP" && sudo mv "$TMP" /usr/local/src/${binName} && chmod +x /usr/local/src/${binName}`
}
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing the binary release for ${pkg}`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'brew') {
for (let pkg of packages) {
try {
runCommand(`Installing ${pkg} via ${packageManager}`, `brew install --quiet ${pkg}`)
2023-01-04 20:57:52 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with brew`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'cask') {
for (let pkg of packages) {
try {
runCommand(`Installing ${pkg} via ${packageManager}`, `brew install --cask --no-quarantine --quiet ${pkg}`)
2023-01-04 20:57:52 -08:00
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with Homebrew Cask`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'cargo') {
for (const pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `cargo install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with Cargo`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'choco') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `choco install -y ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with Chocolatey`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'crew') {
} else if (packageManager === 'dnf') {
const dnf = which.sync('dnf', { nothrow: true })
const yum = which.sync('yum', { nothrow: true })
2023-01-03 20:39:23 -08:00
for (let pkg of packages) {
if (dnf) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo dnf install -y ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with dnf`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2023-01-03 20:39:23 -08:00
} else if (yum) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo yum install -y ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with yum`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'flatpak') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo flatpak install -y flathub ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with flatpak`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'gem') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `gem install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with gem`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'go') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `go install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with go`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'nix') {
} else if (packageManager === 'npm') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `volta install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with volta`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'pacman') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo pacman -Sy --noconfirm --needed ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with pacman`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'pipx') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `pipx install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-11-05 19:50:23 -08:00
log('warn', 'Install', `There was an error installing ${pkg} with pipx, re-attempting using pip3`)
2023-01-04 20:57:52 -08:00
console.error(e)
2023-11-05 19:50:23 -08:00
try {
runCommand(`Installing ${pkg} via pip3`, `pip3 install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via pip3`)
} catch (e) {
log('error', 'Install', `There was an error installing ${pkg} with both pipx and pip3`)
console.error(e)
}
}
2022-11-29 22:26:34 -08:00
}
} else if (packageManager === 'pkg-darwin') {
for (let pkg of packages) {
try {
runCommand(`Installing ${pkg} via ${packageManager}`, `TMP="$(mktemp)" && curl -sSL "${pkg}" > "$TMP" && sudo installer -pkg "$TMP" -target /`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
log('error', 'Install', `There was an error installing ${pkg} with the system installer`)
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'port') {
const port = which.sync('port', { nothrow: true })
if (port) {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo port install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with port`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
} else {
log(
2022-12-24 20:48:43 -08:00
'error',
'Port Not Installed',
`Unable to install with port because it is not installed. Skipping installation of ${packages}`
2022-12-24 20:48:43 -08:00
)
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'scoop') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `scoop install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with scoop`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'snap') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo snap install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with snap`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'script') {
for (let pkg of packages) {
try {
await $`bash -c ${pkg}`
2022-12-24 20:48:43 -08:00
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error running the script installation method for ${pkg}`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'snap-classic') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo snap install --classic ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
2022-12-24 20:48:43 -08:00
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with snap in classic mode`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'whalebrew') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `whalebrew install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with whalebrew`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'winget') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `winget install ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with winget`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'yay') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `yay -Sy --noconfirm --needed ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with yay`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
2022-11-29 22:26:34 -08:00
}
2022-12-24 20:48:43 -08:00
} else if (packageManager === 'zypper') {
for (let pkg of packages) {
try {
2023-01-04 20:57:52 -08:00
runCommand(`Installing ${pkg} via ${packageManager}`, `sudo zypper install -y ${pkg}`)
log('success', 'Install', `${pkg} successfully installed via ${packageManager}`)
} catch (e) {
2023-01-09 05:05:00 -08:00
log('error', 'Install', `There was an error installing ${pkg} with zypper`)
2023-01-04 20:57:52 -08:00
console.error(e)
}
}
2022-11-29 22:26:34 -08:00
}
} catch (e) {
2022-12-24 20:48:43 -08:00
log('error', logStage, `Possibly encountered an error while installing via \`${packageManager}\``)
log('info', logStage, `Proceeding with the installation..`)
2022-11-29 22:26:34 -08:00
}
}
async function addUserGroup(group) {
const logStage = 'Users / Groups'
log('info', logStage, `Ensuring the ${group} group / user is added`)
2023-11-26 22:11:08 -08:00
runCommand(`Creating the ${group} user / group`, `bash -c 'sudo add-user ${group}'`)
}
2023-06-27 19:53:52 -07:00
/**
* Adds the rules specified in the `_ports` key of each entry in the `software.yml` file.
*
2023-06-27 22:37:45 -07:00
* @param rule {packageKey: string, ports: any} Firewall rule in the form of 8888/tcp or 9999/udp. Can also be the XML file name stored in ~/.config/firewall/etc/firewalld/services.
2023-06-27 19:53:52 -07:00
*/
async function addFirewallRule(rule) {
2023-06-27 22:37:45 -07:00
try {
const logStage = 'Firewall'
const packageName = installData.softwarePackages[rule.packageKey] && installData.softwarePackages[rule.packageKey]._name
const packageDesc = installData.softwarePackages[rule.packageKey] && installData.softwarePackages[rule.packageKey]._desc
log('info', logStage, `Ensuring the ${rule.packageKey} rule is added since the _ports key is defined`)
if (osType === 'linux') {
const firewallCmd = which.sync('firewall-cmd', { nothrow: true })
// const ufw = which.sync('ufw', { nothrow: true })
if (firewallCmd) {
const serviceFile = `${process.env.HOME}/.config/firewall/etc/firewalld/services/${rule.packageKey}.xml`
if (fileExists(serviceFile)) {
log('info', logStage, `Service file found at ${serviceFile} - using it to apply firewall-cmd configuration`)
runCommand(`Copying over ${serviceFile} file to /etc/firewalld/services`, `sudo cp -f "${serviceFile}" "/etc/firewalld/services/${rule.packageKey}.xml"`)
runCommand(`Adding the ${rule.packageKey} firewall-cmd service`, `sudo firewall-cmd --add-service=${rule.packageKey} --permanent`)
} else {
if (typeof rule.ports === 'string') {
runCommand(`Adding the ${rule.packageKey} ${rule.ports} rule to the firewall configuration`, `sudo firewall-cmd --add-port=${rule.ports} --permanent`)
} else {
for (const port of rule.ports) {
if (typeof port === 'string') {
runCommand(`Adding the ${rule.packageKey} ${rule.ports} rule to the firewall configuration`, `sudo firewall-cmd --add-port=${rule.ports} --permanent`)
} else if (port.port && port.proto) {
runCommand(`Adding the ${rule.packageKey} ${port.port}/${port.proto} rule to the firewall configuration`, `sudo firewall-cmd --add-port=${port.port}/${port.proto} --permanent`)
} else {
log('error', logStage, `Unable to parse the firewall definition for ${rule.packageKey}`)
}
}
}
}
} else {
log('error', logStage, `The firewall-cmd executable is not present on the system so the firewall cannot be configured`)
}
} else if (osType === 'darwin') {
const socketFilterFw = '/usr/libexec/ApplicationFirewall/socketfilterfw'
const serviceFile = `${process.env.HOME}/.config/firewall/darwin/${rule.packageKey}.sh`
if (fileExists(serviceFile)) {
runCommand(`Executing the matching ${serviceFile} service file`, `sudo bash "${serviceFile}"`)
2023-06-27 19:53:52 -07:00
} else {
if (typeof rule.ports === 'string') {
2023-06-27 22:37:45 -07:00
log('error', logStage, `_ports rules that are equal to strings are not yet implemented on macOS (package: ${rule.packageKey})`)
} else {
for (const port of rule.ports) {
if (typeof port === 'string') {
log('error', logStage, `_ports rules that are equal to strings are not yet implemented on macOS (package: ${rule.packageKey})`)
} else if (port.port && port.proto) {
if (packageDesc) {
2023-11-05 20:27:24 -08:00
runCommand(`Adding new service with description populated for ${rule.packageKey}`, `${socketFilterFw} --add --service "${packageName ? packageName : rule.packageKey}" --setglobaldescription "${packageDesc} --getglobalstate"`)
} else {
runCommand(`Adding new service for ${rule.packageKey}`, `${socketFilterFw} --add --service "${packageName ? packageName : rule.packageKey}" --getglobalstate`)
2023-06-27 22:37:45 -07:00
}
2023-11-05 20:27:24 -08:00
runCommand(`Adding firewall rule for ${rule.packageKey}`, `${socketFilterFw} --add --service "${packageName ? packageName : rule.packageKey}" --port ${port.port} --protocol ${port.proto}`)
2023-06-27 22:37:45 -07:00
} else {
log('error', logStage, `Unable to parse the firewall definition for ${rule.packageKey}`)
}
}
}
2023-06-27 19:53:52 -07:00
}
2023-06-27 22:37:45 -07:00
} else if (osType === 'windows') {
log('warn', logStage, `Windows support not yet added`)
2023-06-27 19:53:52 -07:00
} else {
2023-06-27 22:37:45 -07:00
log('warn', logStage, `Unknown operating system type`)
2023-06-27 19:53:52 -07:00
}
2023-06-27 22:37:45 -07:00
} catch (e) {
console.log(e)
log('error', 'Bin', `Error configuring firewall settings for ${rule.packageKey}`)
2023-06-27 19:53:52 -07:00
}
}
async function updateService(service) {
const logStage = 'Service Service'
2022-12-24 20:48:43 -08:00
if (osType === 'linux') {
const systemctl = which.sync('systemctl', { nothrow: true })
const brew = which.sync('brew', { nothrow: true })
if (systemctl) {
try {
2023-01-08 21:30:07 -08:00
runCommand(`Starting / enabling ${service} with systemctl`, `sudo systemctl enable --now ${service}`)
log('success', logStage, `Started / enabled the ${service} service`)
} catch (e) {
log('info', logStage, `There was an error starting / enabling the ${service} service with systemd`)
try {
if (brew) {
2023-12-01 14:10:05 -08:00
if (typeof brew === 'object' && brew.length) {
brew.forEach(x => {
runCommand(`Starting / enabling object array ${service} with Homebrew`, `${x.sudo ? 'sudo brew' : 'brew'} services start ${x.name}`)
log('success', logStage, `Started / enabled the ${x.name} service with Homebrew`)
})
} else if (typeof brew === 'object') {
runCommand(`Starting / enabling object ${service} with Homebrew`, `${brew.sudo ? 'sudo brew' : 'brew'} services start ${brew.name}`)
log('success', logStage, `Started / enabled the ${brew.name} service with Homebrew`)
} else {
runCommand(`Starting / enabling ${service} with Homebrew`, `brew services start ${service}`)
log('success', logStage, `Started / enabled the ${service} service with Homebrew`)
}
} else {
log('error', logStage, `Unable to start service with systemd and Homebrew is not available`)
}
} catch (err) {
log('error', logStage, `Unable to start service with both systemd and Homebrew`)
log('info', logStage, `systemd error`)
console.error(e)
log('info', logStage, `brew services error`)
console.error(e)
}
}
} else {
2022-12-24 20:48:43 -08:00
log(
'warn',
logStage,
`The systemctl command is not available so applications with services cannot be started / enabled`
)
}
} else if (osType === 'darwin') {
const brew = which.sync('brew', { nothrow: true })
if (brew) {
try {
2023-07-08 23:46:28 -07:00
runCommand(`Starting / enabling ${service} with Homebrew`, `brew services start ${service}`)
2023-01-08 21:30:07 -08:00
log('success', logStage, `Started / enabled the ${service} service with Homebrew`)
2022-12-24 08:48:46 -08:00
} catch (e) {
2022-12-24 20:48:43 -08:00
log('error', logStage, `There was an error starting / enabling the ${service} Homebrew service`)
2022-12-24 08:48:46 -08:00
console.error(e)
}
} else {
2022-12-24 20:48:43 -08:00
log('warn', logStage, `Homebrew is not available - skipping service start command`)
}
}
}
/**
2023-01-09 04:30:16 -08:00
* Filter that resolves when all asynchronous filter actions are done
*/
const asyncFilter = async (arr, predicate) => {
2023-01-09 04:30:16 -08:00
const results = await Promise.all(arr.map(predicate))
2023-01-09 04:30:16 -08:00
return arr.filter((_v, index) => results[index])
}
2023-01-03 20:39:23 -08:00
async function pruneInstallOrders(installOrders) {
const newOrders = Object.assign({}, installOrders)
2023-01-04 21:17:32 -08:00
log('info', 'Filter', 'Removing packages from installOrders that are already installed')
2023-01-04 19:04:55 -08:00
for (const pkgManager in installOrders) {
2023-01-04 21:17:32 -08:00
log('info', 'Filter', `Filtering the ${pkgManager} installOrders`)
2023-02-15 22:14:03 -08:00
console.log('List to be filtered:', newOrders[pkgManager])
if (pkgManager === 'appimage') {
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
try {
2023-01-09 04:34:45 -08:00
await runSilentCommand(`zap list | grep "${pkg}" > /dev/null`)
return false
} catch (e) {
return true
}
})
} else if (pkgManager === 'apt') {
2023-01-04 19:45:25 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
2023-01-03 20:39:23 -08:00
try {
await runSilentCommand(`dpkg -l ${pkg} | grep -E '^ii' > /dev/null`)
2023-01-04 19:45:25 -08:00
return false
2023-01-04 20:09:38 -08:00
} catch (e) {
return true
2023-01-03 20:39:23 -08:00
}
})
2023-01-03 21:28:46 -08:00
} else if (pkgManager === 'brew') {
2023-01-04 19:52:42 -08:00
let newVal = newOrders[pkgManager]
2023-02-15 22:17:29 -08:00
const pkgTmp = '/tmp/brew-list-install-doctor'
runCommand(`Populating temporary file with list of Homebrew packages`, `brew list > ${pkgTmp}`)
2023-01-04 20:20:38 -08:00
for (const pkg of newOrders[pkgManager]) {
2023-01-03 21:28:46 -08:00
try {
2023-02-15 22:17:29 -08:00
await $`cat ${pkgTmp} | grep '^${pkg}$'`
2023-07-17 13:40:40 -07:00
log('info', 'Filter', 'Filtering list')
2023-07-17 15:06:36 -07:00
newVal = newVal.filter((x) => x !== pkg)
2023-07-17 13:40:40 -07:00
console.log('New list', newVal)
2023-01-03 21:28:46 -08:00
} catch (e) {
2023-01-03 23:33:00 -08:00
// Do nothing
2023-01-03 21:28:46 -08:00
}
2023-01-03 23:33:00 -08:00
}
2023-01-04 19:52:42 -08:00
newOrders[pkgManager] = newVal
2023-01-03 20:39:23 -08:00
} else if (pkgManager === 'dnf') {
const dnf = which.sync('dnf', { nothrow: true })
2023-01-04 19:45:25 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
2023-01-03 20:39:23 -08:00
try {
if (dnf) {
await runSilentCommand(`rpm -qa | grep '$'"${pkg}-" > /dev/null`)
2023-01-03 20:39:23 -08:00
} else {
await runSilentCommand(`rpm -qa | grep '$'"${pkg}-" > /dev/null`)
2023-01-03 20:39:23 -08:00
}
2023-01-04 19:45:25 -08:00
return false
2023-01-04 20:09:38 -08:00
} catch (e) {
return true
2023-01-03 20:39:23 -08:00
}
})
} else if (pkgManager === 'flatpak') {
const flatpakInstallation = await $`flatpak --installations`
2023-01-08 23:17:09 -08:00
const flatpakDir = flatpakInstallation.stdout.replace('\n', '')
2023-01-05 22:46:14 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
try {
2023-01-08 21:30:07 -08:00
await runSilentCommand(`test -d ${flatpakDir}/app/${pkg}`)
2023-01-05 22:46:14 -08:00
return false
} catch (e) {
return true
}
})
2023-01-05 22:33:56 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
2023-01-03 20:39:23 -08:00
try {
await runSilentCommand(`flatpak info ${pkg} > /dev/null`)
2023-01-04 19:45:25 -08:00
return false
} catch (e) {
return true
2023-01-03 20:39:23 -08:00
}
})
} else if (pkgManager === 'pacman') {
2023-01-04 19:45:25 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
2023-01-03 20:39:23 -08:00
try {
2023-01-05 22:33:56 -08:00
await runSilentCommand(`pacman -Qs ${pkg} > /dev/null`)
2023-01-04 21:47:56 -08:00
return false
} catch (e) {
return true
}
})
} else if (pkgManager === 'snap' || pkgManager === 'snap-classic') {
2023-01-04 21:47:56 -08:00
newOrders[pkgManager] = await asyncFilter(newOrders[pkgManager], async (pkg) => {
try {
await runSilentCommand(`snap list ${pkg} | grep ${pkg} > /dev/null`)
2023-01-04 19:45:25 -08:00
return false
2023-01-04 20:09:38 -08:00
} catch (e) {
return true
2023-01-03 20:39:23 -08:00
}
})
}
2023-01-04 20:09:38 -08:00
log('info', 'Filter', `Finished filtering ${pkgManager}`)
2023-02-15 22:14:03 -08:00
console.log('Filtered list:', newOrders[pkgManager])
2023-01-03 20:39:23 -08:00
}
return newOrders
}
async function installPlugins(pluginData) {
2023-01-08 23:25:38 -08:00
if (pluginData.cmd && pluginData.plugins && pluginData.plugins.length) {
for (const plugin of pluginData.plugins) {
try {
const pluginCmd = pluginData.cmd.replace(/{PLUGIN}/g, plugin)
2023-08-18 11:11:14 -07:00
const pluginWhen = pluginData.when
try {
if (pluginWhen) {
runCommand(`Checking when condition for ${pluginData.package} plugin - ${plugin}`, pluginWhen)
}
2023-11-06 01:56:49 -08:00
try {
runCommand(`Installing ${pluginData.package} plugin - ${plugin}`, pluginCmd)
log('success', 'Plugin', `Successfully installed ${pluginData.package} plugin - ${plugin}`)
} catch (e) {
log('info', 'Plugin', `Failed to install ${pluginData.package} plugin - ${plugin}`)
console.error(e)
}
2023-08-18 11:11:14 -07:00
} catch (e) {
2023-11-06 01:56:49 -08:00
log('info', 'Plugin', `Skipping ${pluginData.package} plugin installs due to failed when condition - ${pluginWhen}`)
break
2023-08-18 11:11:14 -07:00
}
2023-01-08 23:25:38 -08:00
} catch (e) {
2023-11-06 01:56:49 -08:00
log('error', 'Plugin', `Failed to install ${pluginData.package} plugin due to an unknown reason - ${plugin}`)
2023-01-08 23:25:38 -08:00
console.error(e)
}
2023-08-18 11:11:14 -07:00
}
}
2023-07-31 11:10:54 -07:00
if (pluginData.update) {
const pluginDataPackage = pluginData.package
if (pluginDataPackage) {
runCommand('Updating ' + pluginDataPackage + ' plugins', pluginData.update)
}
2023-07-31 11:10:54 -07:00
}
}
async function linkBin(installOrdersBinLink) {
let flatpakInstallation, flatpakDir
2023-01-08 23:26:28 -08:00
const softwarePackages = installData.softwarePackages
const flatpak = which.sync('flatpak', { nothrow: true })
if (flatpak) {
flatpakInstallation = await $`flatpak --installations`
flatpakDir = flatpakInstallation.stdout.replace('\n', '')
}
for (const binLink of installOrdersBinLink) {
const pkg = softwarePackages[binLink.package][binLink.preference]
2023-01-09 04:30:16 -08:00
if (typeof pkg === 'string') {
2023-11-27 13:13:11 -08:00
if (binLink.bin !== false) {
if (!which.sync(binLink.bin, { nothrow: true })) {
if (binLink.preference === 'flatpak' && flatpak) {
try {
2023-01-09 04:30:16 -08:00
runCommand(
2023-11-27 13:13:11 -08:00
`Adding bin link for ${pkg} (${binLink.bin})`,
`bash -c 'test -d ${flatpakDir}/app/${pkg} && mkdir -p "${process.env.HOME}/.local/bin/flatpak" && echo "flatpak run ${pkg} \\\$*" > "${process.env.HOME}/.local/bin/flatpak/${binLink.bin}" && chmod +x "${process.env.HOME}/.local/bin/flatpak/${binLink.bin}"'`
2023-01-09 04:30:16 -08:00
)
2023-11-27 13:13:11 -08:00
log('success', 'Bin', `Linked ~/.local/bin/flatpak/${binLink.bin} to the ${pkg} Flatpak`)
} catch (e) {
log('warn', 'Bin', `Expected flatpak directory not available - ${flatpakDir}/app/${pkg}`)
}
} else if (binLink.preference === 'cask') {
try {
const caskWhen = softwarePackages[binLink.package]['_when:cask'].replace(/blue/g, "red")
const appName = caskWhen.replace(/ && ! test -d .*/, '').replace(/! test -d "\/Applications\//, '').replace(/! test -d \/Applications\//, '').replace('"', '')
log('info', 'Bin', `Checking for existence of ${appName} application in /Applications and ~/Applications`)
if (fileExists(`/Applications/${appName}`)) {
runCommand(
`Adding shortcut bin link for ${binLink.package}`,
`bash -c 'mkdir -p "${process.env.HOME}/.local/bin/cask" && echo "open \"/Applications/${appName}\" \\\$*" > "${process.env.HOME}/.local/bin/cask/${binLink.bin}" && chmod +x "${process.env.HOME}/.local/bin/cask/${binLink.bin}"'`
)
} else if(fileExists(`${process.env.HOME}/Applications/${appName}`)) {
runCommand(
`Adding shortcut bin link for ${binLink.package}`,
`bash -c 'mkdir -p "${process.env.HOME}/.local/bin/cask" && echo "open \"${process.env.HOME}/Applications/${appName}\" \\\$*" > "${process.env.HOME}/.local/bin/cask/${binLink.bin}" && chmod +x "${process.env.HOME}/.local/bin/cask/${binLink.bin}"'`
)
} else {
log('warn', 'Bin', `Expected Homebrew cask directory not found - ${pkg}`)
}
} catch (e) {
console.log(e)
log('warn', 'Bin', `Error creating bin shortcut link for ${pkg}`)
}
}
2023-11-27 13:13:11 -08:00
} else {
log('info', 'Bin', `Link already exists for ${binLink.package}`)
}
} else {
2023-11-27 13:13:11 -08:00
log('info', 'Bin', `Skipping ${binLink.package} because the _bin is equal to false`)
}
} else {
log('info', 'Bin', `Skipping ${binLink.package} because there was more than one _bin value`)
}
}
}
2022-11-29 22:26:34 -08:00
// main process
async function installSoftware(pkgsToInstall) {
2022-12-24 20:48:43 -08:00
osType = await OSType()
osID = osType
if (osType === 'linux') {
osID = await releaseID()
}
2022-12-24 20:48:43 -08:00
log('info', 'Catalog Download', `Fetching the latest version of the installation map`)
installData = await downloadInstallData()
chezmoiData = await getChezmoiData()
2023-01-04 21:17:32 -08:00
log('info', 'Filter', `Calculating the install orders`)
2022-12-24 20:48:43 -08:00
await generateInstallOrders(pkgsToInstall ? pkgsToInstall : process.argv.slice(3))
const packageManagers = Object.keys(installOrders)
2023-02-01 09:20:19 -08:00
packageManagers.length && log('info', 'Pre-Reqs', `Ensuring any package managers that will be used are installed / configured`)
2022-11-29 22:26:34 -08:00
for (const packageManager of packageManagers) {
2022-12-24 20:48:43 -08:00
await ensurePackageManager(packageManager)
2022-11-29 22:26:34 -08:00
}
2022-12-24 08:57:06 -08:00
try {
for (const key in installOrders) {
2022-12-24 20:48:43 -08:00
installOrders[key] = [...new Set(installOrders[key])]
2022-12-24 08:57:06 -08:00
}
2023-01-04 21:17:32 -08:00
log('info', 'Install', `The install orders were generated:`)
2022-12-24 08:57:06 -08:00
} catch (e) {
2023-01-04 21:17:32 -08:00
log('error', 'Filter', `There was an error reducing the duplicates in the install orders`)
2022-12-24 08:57:06 -08:00
console.error(e)
}
2023-01-03 20:39:23 -08:00
installOrders = await pruneInstallOrders(installOrders)
2023-05-29 19:28:25 -07:00
delete installOrders._deps
2023-02-15 22:14:03 -08:00
console.log('Install orders:', installOrders)
2023-02-01 09:20:19 -08:00
packageManagers.length && log('info', 'Pre-Reqs', `Running package manager pre-installation steps`)
2022-11-29 22:26:34 -08:00
for (const packageManager of packageManagers) {
2022-12-24 20:48:43 -08:00
await beforeInstall(packageManager)
2022-11-29 22:26:34 -08:00
}
2023-02-01 09:20:19 -08:00
installOrdersPre.length && log('info', 'Pre-Install', `Running package-specific pre-installation steps`)
2022-11-29 22:26:34 -08:00
for (const script of installOrdersPre) {
2023-11-07 20:57:15 -08:00
const timeoutAvail = which.sync('timeout', { nothrow: true })
if (timeoutAvail) {
await $`${['timeout', '1000', 'bash', '-c', script]}`
} else {
await $`${['bash', '-c', script]}`
}
2022-11-29 22:26:34 -08:00
}
installOrdersGroups.length && log('info', 'Users / Groups', `Adding groups / users`)
for (const group of installOrdersGroups) {
await addUserGroup(group)
}
2023-02-01 09:20:19 -08:00
packageManagers.length && log('info', 'Install', `Installing the packages`)
2022-11-29 22:26:34 -08:00
for (const packageManager of packageManagers) {
2022-12-24 20:48:43 -08:00
const asyncOrders = []
asyncOrders.push(installPackageList(packageManager, installOrders[packageManager]))
await Promise.all(asyncOrders)
2022-11-29 22:26:34 -08:00
}
2023-06-27 19:53:52 -07:00
installOrdersPorts.length && log('info', 'Firewall', 'Configuring firewall exceptions')
for (const firewallRule of installOrdersPorts) {
await addFirewallRule(firewallRule)
}
2023-02-01 09:20:19 -08:00
installOrdersService.length && log('info', 'Post-Install', `Running package-specific post-installation steps`)
for (const service of installOrdersService) {
await updateService(service)
}
if (!binLinkRan) {
binLinkRan = true
log('info', 'Bin', 'Linking bin aliases to their installed packages')
await linkBin(installOrdersBinLink)
2023-06-04 20:26:37 -07:00
}
for (const script of installOrdersPost) {
try {
log('info', 'Post Hook', script)
2023-11-07 20:57:15 -08:00
const timeoutAvail = which.sync('timeout', { nothrow: true })
if (timeoutAvail) {
await $`${['timeout', '1000', 'bash', '-c', script]}`
} else {
await $`${['bash', '-c', script]}`
}
2023-06-04 20:26:37 -07:00
} catch(e) {
log('info', 'Post-Install Hook', 'Encountered error while running post-install hook')
}
}
2023-02-01 09:20:19 -08:00
installOrdersPlugins.length && log('info', 'Plugin', 'Installing package-specific plugins')
for (const plugin of installOrdersPlugins) {
await installPlugins(plugin)
}
2023-02-01 09:20:19 -08:00
packageManagers.length && log('info', 'Post-Install', `Running package manager post-installation steps`)
2022-11-29 22:26:34 -08:00
for (const packageManager of packageManagers) {
2022-12-24 20:48:43 -08:00
await afterInstall(packageManager)
2022-11-29 22:26:34 -08:00
}
2023-01-04 21:17:32 -08:00
log('success', 'Complete', `Done!`)
2022-11-29 22:26:34 -08:00
}
// Start the main process
2022-12-24 20:48:43 -08:00
await installSoftware(false)