Files
orca/config/scripts/native-build/windows/build-windows-security-addon.mjs
Neil c3a681f5b1 refactor: group process and platform modules by ownership (#42742)
* refactor: group process and platform modules by ownership

* refactor: preserve moved module workflow routing

* refactor: preserve native loader and embedded bundle origins
2026-11-15 07:23:28 -08:00

170 lines
5.8 KiB
JavaScript

#!/usr/bin/env node
// Compile N-API privacy addon for pinned-Node orcad; missing addon fails startup closed.
// Build a private copy to preserve desktop host addon; Windows x64 cross-compiles arm64. Usage: --arch=arm64.
import { copyFileSync, cpSync, existsSync, mkdirSync, rmSync } from 'node:fs'
import { createRequire } from 'node:module'
import { isAbsolute, join, resolve } from 'node:path'
import { pathToFileURL } from 'node:url'
import { runProcessSync } from '@orca/process-host'
import { NODE_RUNTIME_ASSETS } from '../../../../src/shared/node-runtime/node-runtime-pin.ts'
import { sha256Of } from '../../orcad-distribution/prebuilds/orcad-prebuild-slot-contents.mjs'
import { ORCAD_WINDOWS_SECURITY_FILENAME } from '../../../../src/shared/remote-runtime/orcad-distribution/orcad-artifacts.ts'
const { PE_MACHINE, describePeMachine, readPeMachine } = createRequire(import.meta.url)(
'./windows-pe-machine.cjs'
)
const ROOT = resolve(import.meta.dirname, '../../..', '..')
const SUPPORTED_ARCHES = ['x64', 'arm64']
export function windowsSecurityAddonOutput(root, arch) {
return join(root, '.build', 'windows-security', arch, ORCAD_WINDOWS_SECURITY_FILENAME)
}
export function probeWindowsSecurityAddon(
runtimePath,
candidate,
arch,
run = runProcessSync,
cwd = ROOT
) {
return run({
program: runtimePath,
args: [
'-e',
`if (process.platform !== 'win32' || process.arch !== ${JSON.stringify(arch)} || process.versions.electron) process.exit(1);` +
`const sid = require(${JSON.stringify(candidate)}).currentUserSid();` +
`if (typeof sid !== 'string' || !/^S-1-\\d+(?:-\\d+)+$/.test(sid)) process.exit(2);` +
`process.stdout.write('windows-security-ready');`
],
cwd,
timeoutMs: 30_000
})
}
export function reusePreparedWindowsSecurityAddon(
arch,
output,
{
enabled = false,
runtimePath,
root = ROOT,
platform = process.platform,
hostArch = process.arch,
runtimeAssets = NODE_RUNTIME_ASSETS,
run = runProcessSync
} = {}
) {
if (!enabled || platform !== 'win32' || arch !== hostArch || !runtimePath) {
return false
}
const candidate = resolve(
root,
'native/windows-security/build/Release/orca_windows_security.node'
)
try {
if (
readPeMachine(candidate) !== PE_MACHINE[arch] ||
!isAbsolute(runtimePath) ||
sha256Of(runtimePath) !== runtimeAssets[`win32-${arch}`]?.executableSha256
) {
return false
}
const prepared = run({
program: process.execPath,
args: [
join(root, 'config/scripts/native-build/node-addons/ensure-native-runtime.mjs'),
'--runtime=node',
'--check-only'
],
cwd: root,
timeoutMs: 30_000
})
if (prepared.code !== 0 || prepared.timedOut || prepared.outputTruncated) {
return false
}
const probe = probeWindowsSecurityAddon(runtimePath, candidate, arch, run, root)
if (
probe.code !== 0 ||
probe.timedOut ||
probe.outputTruncated ||
probe.stdout !== 'windows-security-ready'
) {
return false
}
} catch {
return false
}
mkdirSync(resolve(output, '..'), { recursive: true })
copyFileSync(candidate, output)
console.log(`[windows-security] reused prepared ${arch} -> ${output}`)
return true
}
export function buildWindowsSecurityAddon(
arch,
output = windowsSecurityAddonOutput(ROOT, arch),
{ root = ROOT, run = runProcessSync, ...options } = {}
) {
if (!SUPPORTED_ARCHES.includes(arch)) {
throw new Error(`--arch must be one of ${SUPPORTED_ARCHES.join(', ')}; got ${arch}`)
}
if (process.platform !== 'win32') {
throw new Error(
`The Windows security addon only builds on Windows; running on ${process.platform}.`
)
}
if (reusePreparedWindowsSecurityAddon(arch, output, { ...options, root, run })) {
return output
}
// Inside the repo so binding.gyp's `require('node-addon-api')` resolves from root node_modules.
const workDir = join(root, '.build', 'windows-security', arch, 'gyp')
rmSync(workDir, { recursive: true, force: true })
mkdirSync(workDir, { recursive: true })
copyFileSync(join(root, 'native/windows-security/binding.gyp'), join(workDir, 'binding.gyp'))
cpSync(join(root, 'native/windows-security/src'), join(workDir, 'src'), { recursive: true })
const result = run({
program: process.execPath,
args: [
join(root, 'node_modules', 'node-gyp', 'bin', 'node-gyp.js'),
'rebuild',
`--arch=${arch}`
],
cwd: workDir,
stdio: 'inherit',
timeoutMs: null
})
if (result.code !== 0) {
throw new Error(`node-gyp failed for ${arch} with exit ${result.code}`)
}
const built = join(workDir, 'build', 'Release', 'orca_windows_security.node')
if (!existsSync(built)) {
throw new Error(`node-gyp reported success but ${built} is missing.`)
}
// Why check the artifact: node-gyp can ignore --arch, and a host could not load the result.
const machine = readPeMachine(built)
if (machine !== PE_MACHINE[arch]) {
throw new Error(`Built binary is ${describePeMachine(machine)}, expected ${arch}.`)
}
mkdirSync(resolve(output, '..'), { recursive: true })
copyFileSync(built, output)
console.log(`[windows-security] ${arch} -> ${output}`)
return output
}
if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
try {
const arch =
process.argv.find((arg) => arg.startsWith('--arch='))?.slice('--arch='.length) ?? process.arch
buildWindowsSecurityAddon(arch, undefined, {
enabled: process.argv.includes('--reuse-prepared-runtime'),
runtimePath: process.argv
.find((arg) => arg.startsWith('--node-runtime='))
?.slice('--node-runtime='.length)
})
} catch (error) {
console.error(`[windows-security] ${error instanceof Error ? error.message : String(error)}`)
process.exit(1)
}
}