File size: 5,606 Bytes
58a9693 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | /** Download and verify the upstream Node.js runtime and copy the pinned pnpm CLI. */
import { createHash } from 'node:crypto'
import { spawnSync } from 'node:child_process'
import { cpSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { chmod, readFile } from 'node:fs/promises'
import { createRequire } from 'node:module'
import { dirname, join } from 'node:path'
import { pipeline } from 'node:stream/promises'
import extractZip from 'extract-zip'
import { extract } from 'tar'
import { resolveDesktopTargetBuildPaths } from './desktop-build-paths.mjs'
const NODE_VERSION = '24.17.0'
const BUILD_PATHS = resolveDesktopTargetBuildPaths()
const RUNTIME_ROOT = BUILD_PATHS.runtime
const DOWNLOAD_ROOT = BUILD_PATHS.downloads
type RuntimePlatform = 'darwin' | 'linux' | 'win'
type RuntimeArch = 'arm64' | 'x64'
function target(): { platform: RuntimePlatform; arch: RuntimeArch } {
const rawPlatform = process.env.DSH_DESKTOP_TARGET_PLATFORM ?? process.env.npm_config_platform ?? process.platform
const rawArch = process.env.DSH_DESKTOP_TARGET_ARCH ?? process.env.npm_config_arch ?? process.arch
const platform = rawPlatform === 'win32' ? 'win' : rawPlatform
if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win') {
throw new Error(`desktop runtime: unsupported platform ${rawPlatform}`)
}
if (rawArch !== 'arm64' && rawArch !== 'x64') throw new Error(`desktop runtime: unsupported architecture ${rawArch}`)
return { platform, arch: rawArch }
}
async function download(url: string, path: string): Promise<void> {
const response = await fetch(url)
if (!response.ok) throw new Error(`desktop runtime: ${url} returned HTTP ${String(response.status)}`)
writeFileSync(path, new Uint8Array(await response.arrayBuffer()), { mode: 0o600 })
}
async function prepareNode(platform: RuntimePlatform, arch: RuntimeArch): Promise<void> {
const extension = platform === 'win' ? 'zip' : 'tar.gz'
const folder = `node-v${NODE_VERSION}-${platform}-${arch}`
const archiveName = `${folder}.${extension}`
const releaseRoot = `https://nodejs.org/download/release/v${NODE_VERSION}`
const archive = join(DOWNLOAD_ROOT, archiveName)
const sums = join(DOWNLOAD_ROOT, `node-v${NODE_VERSION}-SHASUMS256.txt`)
if (!existsSync(archive)) await download(`${releaseRoot}/${archiveName}`, archive)
if (!existsSync(sums)) await download(`${releaseRoot}/SHASUMS256.txt`, sums)
const line = (await readFile(sums, 'utf8')).split(/\r?\n/u)
.find(candidate => candidate.endsWith(` ${archiveName}`))
if (line === undefined) throw new Error(`desktop runtime: ${archiveName} is absent from Node.js SHASUMS256.txt`)
const expected = line.split(/\s+/u)[0]
const actual = createHash('sha256').update(await readFile(archive)).digest('hex')
if (actual !== expected) throw new Error(`desktop runtime: checksum mismatch for ${archiveName}`)
const extraction = BUILD_PATHS.nodeExtract
rmSync(extraction, { recursive: true, force: true })
mkdirSync(extraction, { recursive: true })
if (platform === 'win') await extractZip(archive, { dir: extraction })
else await extract({ cwd: extraction, file: archive })
const source = join(extraction, folder, platform === 'win' ? 'node.exe' : 'bin/node')
const destinationRoot = join(RUNTIME_ROOT, 'node')
const destination = join(destinationRoot, platform === 'win' ? 'node.exe' : 'node')
rmSync(destinationRoot, { recursive: true, force: true })
mkdirSync(destinationRoot, { recursive: true })
// A fresh write prevents macOS from retaining invalid code-signature vnode state from a tar-extracted Mach-O clone.
await pipeline(createReadStream(source), createWriteStream(destination, { flags: 'wx' }))
if (platform !== 'win') await chmod(destination, 0o755)
const hostPlatform = process.platform === 'win32' ? 'win' : process.platform
const hostCanExecute = platform === hostPlatform
&& (arch === process.arch || (platform === 'darwin' && arch === 'x64' && process.arch === 'arm64'))
if (hostCanExecute) {
const result = spawnSync(destination, ['--version'], { encoding: 'utf8' })
if (result.error !== undefined || result.status !== 0 || result.stdout.trim() !== `v${NODE_VERSION}`) {
const detail = result.error?.message ?? result.signal ?? result.stderr.trim()
const outcome = detail === '' ? `exit ${String(result.status)}` : detail
throw new Error(`desktop runtime: prepared Node.js ${NODE_VERSION} failed executable verification: ${outcome}`)
}
}
rmSync(extraction, { recursive: true, force: true })
}
function preparePnpm(): string {
const require = createRequire(import.meta.url)
const manifestPath = require.resolve('pnpm')
const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as { version?: unknown }
if (typeof manifest.version !== 'string') throw new Error('desktop runtime: pnpm manifest has no version')
const packageDir = dirname(manifestPath)
const destination = join(RUNTIME_ROOT, 'pnpm')
rmSync(destination, { recursive: true, force: true })
cpSync(packageDir, destination, { recursive: true })
return manifest.version
}
async function main(): Promise<void> {
const { platform, arch } = target()
mkdirSync(DOWNLOAD_ROOT, { recursive: true })
mkdirSync(RUNTIME_ROOT, { recursive: true })
await prepareNode(platform, arch)
const pnpmVersion = preparePnpm()
writeFileSync(join(RUNTIME_ROOT, 'versions.json'), `${JSON.stringify({
schemaVersion: 1,
node: NODE_VERSION,
pnpm: pnpmVersion,
}, undefined, 2)}\n`)
}
await main()
|