Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
#!/usr/bin/env node
// E2E_GUARDIAN_IPC_FLOW: leased QA preparation and external vendor observation.
// Desktop login, selection, attachment, approval and Send remain visible.
// Operator material is retained in RAM and crosses child stdin only.
import fs from 'node:fs'
import path from 'node:path'
import { spawn } from 'node:child_process'
import { Readable } from 'node:stream'
import { createRequire } from 'node:module'
import { fileURLToPath, pathToFileURL } from 'node:url'
import { isDeepStrictEqual } from 'node:util'
import { prepare, run as command } from './prepare-subscription-image-admission.mjs'
import { run as seed, parseOptions, Channel, buildAuthorizeMemoryCompanionBundle,
openAuthorizeAdmissionPressure } from '../tests/measure-control-api-authorize-memory.mjs'
import { prepareRemainingFixtures } from './prepare-subscription-remaining-fixtures.prepare.mjs'
import { pressureCommandDeadlineMs } from './fixtures/subscription-image-admission-pressure.mjs'
import { admitVendorFrame, digest, RUNNER_RUN_BASE, resolveSuite } from '../tests/lib/subscription-image-runner-contract.mjs'
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
const require = createRequire(import.meta.url)
const projection = require('../../packages/codex-catalog-projection/index.cjs')
const imageCapability = require('../../packages/llm-providers/imageInput.cjs')
const NAMESPACE = 'control-plane'
const IMPORT_PATH = '/app/scripts/e2e/fixtures/subscription-image-provider.mjs'
const PROXY_DOCKERFILE = 'scripts/e2e/fixtures/subscription-image-proxy.Dockerfile'
const PROVIDERS = ['grok-subscription', 'codex-subscription']
export const CATALOG_CRON_KEYS = ['LLM_CATALOG_SYNC_CRON_ENABLED', 'SUBSCRIPTION_CATALOG_SYNC_CRON_ENABLED']
const fail = code => { throw new Error(code) }
const assert = (value, code) => { if (!value) fail(code) }
const validImageId = value => /^sha256:[a-f0-9]{64}$/.test(value ?? '')
const imageId = value => /sha256:[a-f0-9]{64}$/.exec(value ?? '')?.[0]
const pause = ms => new Promise(resolve => setTimeout(resolve, ms))
const json = (context, args, input) => JSON.parse(command('kubectl', ['--context', context,
'--request-timeout=15s', ...args], { input, timeout: 30_000 }))
const getDeployment = (context, name) => json(context, ['-n', NAMESPACE, 'get', 'deployment', name, '-o', 'json'])
const patchDeployment = (context, name, patch) => command('kubectl', ['--context', context,
'--request-timeout=15s', '-n', NAMESPACE, 'patch', 'deployment', name, '--type=json',
'--patch-file=/dev/stdin'], { input: JSON.stringify(patch), timeout: 30_000 })
async function until(check, accept, timeoutMs, code) {
const deadline = Date.now() + timeoutMs
for (;;) {
const value = await check()
if (accept(value)) return value
if (Date.now() >= deadline) fail(code)
await pause(100)
}
}
/** Snapshot only the controlled fields; retain no unrelated environment values. */
export function snapshotDeployment(deployment, containerName, names) {
const containers = deployment?.spec?.template?.spec?.containers
assert(deployment?.spec?.replicas === 1 && !deployment.spec.template.spec.hostNetwork &&
typeof deployment.metadata?.uid === 'string' && Array.isArray(containers), 'COORDINATOR_DEPLOYMENT_INVALID')
const matches = containers.filter(value => value.name === containerName)
assert(matches.length === 1, 'COORDINATOR_CONTAINER_AMBIGUOUS')
const container = matches[0], env = {}
for (const name of names) {
const values = (container.env ?? []).filter(value => value.name === name)
assert(values.length <= 1 && values.every(value => !value.valueFrom && typeof value.value === 'string'),
'COORDINATOR_CONTROLLED_ENV_INVALID')
if (values.length) env[name] = values[0].value
}
if (env.NODE_OPTIONS !== undefined) assert(/^--max-old-space-size=\d+$/.test(env.NODE_OPTIONS),
'COORDINATOR_ORIGINAL_NODE_OPTIONS_UNSUPPORTED')
assert(names.filter(name => !['NODE_OPTIONS', 'NODE_ENV', ...CATALOG_CRON_KEYS].includes(name)).every(name => !(name in env)),
'COORDINATOR_UNRESTORED_FIXTURE')
assert(CATALOG_CRON_KEYS.every(name => env[name] === undefined || ['true', 'false'].includes(env[name])),
'COORDINATOR_CATALOG_CRON_VALUE_UNSUPPORTED')
return { uid: deployment.metadata.uid, containerName, image: container.image, env, names: [...names] }
}
/** UID/RV/image/field CAS in both directions, preserving unrelated fields. */
export function deploymentMutationPatch(current, original, applied, restore = false) {
assert(current?.metadata?.uid === original.uid && typeof current.metadata.resourceVersion === 'string',
'COORDINATOR_DEPLOYMENT_OWNER_CHANGED')
const containers = current.spec.template.spec.containers
const index = containers.findIndex(value => value.name === original.containerName)
assert(index >= 0, 'COORDINATOR_CONTAINER_CHANGED')
const container = containers[index], base = `/spec/template/spec/containers/${index}`
const expected = restore ? applied : original, desired = restore ? original : applied
assert(container.image === expected.image, 'COORDINATOR_IMAGE_RESTORE_CONFLICT')
for (const name of original.names) {
const values = (container.env ?? []).filter(value => value.name === name)
assert(values.length <= 1 && isDeepStrictEqual(values[0], expected.env[name] === undefined ? undefined :
{ name, value: expected.env[name] }), 'COORDINATOR_ENV_RESTORE_CONFLICT')
}
const patch = [{ op: 'test', path: '/metadata/uid', value: original.uid },
{ op: 'test', path: '/metadata/resourceVersion', value: current.metadata.resourceVersion },
{ op: 'test', path: `${base}/name`, value: original.containerName },
{ op: 'test', path: `${base}/image`, value: expected.image },
{ op: 'replace', path: `${base}/image`, value: desired.image }]
if (!container.env) patch.push({ op: 'add', path: `${base}/env`, value: [] })
const removals = []
for (const name of original.names) {
const ei = (container.env ?? []).findIndex(value => value.name === name)
if (ei >= 0) patch.push({ op: 'test', path: `${base}/env/${ei}`, value: container.env[ei] })
if (desired.env[name] === undefined) {
if (ei >= 0) removals.push({ op: 'remove', path: `${base}/env/${ei}` })
} else patch.push({ op: ei >= 0 ? 'replace' : 'add', path: ei >= 0 ? `${base}/env/${ei}` : `${base}/env/-`,
value: { name, value: desired.env[name] } })
}
removals.sort((a, b) => Number(b.path.split('/').at(-1)) - Number(a.path.split('/').at(-1)))
return [...patch, ...removals]
}
function readyPod(context, name, deploymentUid) {
const replicas = json(context, ['-n', NAMESPACE, 'get', 'replicaset', '-o', 'json']).items
.filter(row => row.metadata.ownerReferences?.some(owner => owner.uid === deploymentUid && owner.controller === true))
const ids = new Set(replicas.map(row => row.metadata.uid))
const pods = json(context, ['-n', NAMESPACE, 'get', 'pods', '-o', 'json']).items.filter(row =>
!row.metadata.deletionTimestamp && row.status.phase === 'Running' &&
row.metadata.ownerReferences?.some(owner => ids.has(owner.uid) && owner.controller === true) &&
row.status.containerStatuses?.some(container => container.name === name && container.ready))
return pods.length === 1 ? pods[0] : undefined
}
export async function openControlApiCatalogIsolation(options) {
assert(options.profile === options.context && options.profile !== 'clerum-test' &&
!/(^|-)(prod|production)(-|$)/i.test(options.profile), 'COORDINATOR_CATALOG_CONTEXT_INVALID')
command('bash', [path.join(ROOT, 'scripts/minikube/require-t2-mutation-lock.sh')], { timeout: 10_000 })
const resource = getDeployment(options.context, 'control-api')
const original = snapshotDeployment(resource, 'control-api', CATALOG_CRON_KEYS)
const pod = await until(() => readyPod(options.context, 'control-api', original.uid), Boolean, 120_000,
'COORDINATOR_CATALOG_API_NOT_READY')
const baseImageId = imageId(pod.status.containerStatuses.find(value => value.name === 'control-api').imageID)
assert(validImageId(baseImageId), 'COORDINATOR_CATALOG_API_IMAGE_UNKNOWN')
const applied = { image: original.image, env: Object.fromEntries(CATALOG_CRON_KEYS.map(name => [name, 'false'])) }
const state = { name: 'control-api', original, applied, baseImageId, changed: true }
try {
patchDeployment(options.context, state.name, deploymentMutationPatch(resource, original, applied))
command('kubectl', ['--context', options.context, '-n', NAMESPACE, 'rollout', 'status', 'deployment/control-api', '--timeout=120s'],
{ timeout: 150_000 })
const ready = await until(() => readyPod(options.context, 'control-api', original.uid), Boolean, 120_000,
'COORDINATOR_CATALOG_API_NOT_READY')
const flags = json(options.context, ['-n', NAMESPACE, 'exec', ready.metadata.name, '-c', 'control-api', '--',
'env', '-u', 'NODE_OPTIONS', 'node', '-e',
"const c=require('./dist/config.js').config;process.stdout.write(JSON.stringify({llm:c.llmCatalogSyncCronEnabled,subscription:c.subscriptionCatalogSyncCronEnabled}))"])
assert(flags.llm === false && flags.subscription === false, 'COORDINATOR_CATALOG_CRONS_STILL_ENABLED')
return state
} catch (error) {
// No QA mutation has started while opening this fence, so restore its exact
// original fields even when rollout/observation fails.
await restoreDeployments(options.context, [state])
throw error
}
}
function releaseOptionsForQa(options, receiptFile) {
const fields = { ...options.publicArguments, 'fixtures-receipt': receiptFile,
report: path.join(path.dirname(options.report), `${options.runId}-qa-finalization.json`), prepare: 'restart' }
for (const key of ['prepare-fixtures', 'budget-ids', 'gfs-parent-rid', 'operator-user']) delete fields[key]
return parseOptions(Object.entries(fields).flatMap(([key, value]) => value === true ? [`--${key}`] : [`--${key}`, String(value)]))
}
export function validateMemoryOperatorSelection(options) {
const username = options?.operatorUser
assert(typeof username === 'string' && /^[A-Za-z0-9_.-]{3,64}$/.test(username),
'COORDINATOR_OPERATOR_USERNAME_INVALID')
if (options.prepareFixtures && Object.hasOwn(options.publicArguments ?? {}, 'operator-user')) {
assert(options.publicArguments['operator-user'] === username, 'COORDINATOR_OPERATOR_SOURCE_CHANGED')
return 'existing'
}
if (options.prepareFixtures) {
assert(username === `${options.runId}-operator`, 'COORDINATOR_ISOLATED_OPERATOR_REQUIRED')
return 'generated'
}
assert(options.fixtureBinding, 'COORDINATOR_ISOLATED_OPERATOR_REQUIRED')
return 'fixture'
}
function validatePrivateControlMaterial(material) {
assert(material && typeof material.operatorPassword === 'string' &&
material.operatorPassword.length >= 8 && material.operatorPassword.length <= 1024 &&
(material.cookie === undefined || (typeof material.cookie === 'string' &&
material.cookie.length <= 8192 && !/[\r\n\0]/.test(material.cookie))) &&
(material.desktopPassword === undefined || (typeof material.desktopPassword === 'string' &&
material.desktopPassword.length >= 8 && material.desktopPassword.length <= 1024)) &&
Object.keys(material).every(key => ['operatorPassword', 'cookie', 'desktopPassword'].includes(key)),
'COORDINATOR_PRIVATE_OPERATOR_REQUIRED')
}
export function seedPrivateMaterial(material) {
validatePrivateControlMaterial(material)
return {
operatorPassword: material.operatorPassword,
...(material.cookie === undefined ? {} : { cookie: material.cookie }),
}
}
export function desktopPasswordFor(material) {
validatePrivateControlMaterial(material)
return material.desktopPassword ?? material.operatorPassword
}
/** Physical callers keep this one real CAS fence across all cgroup windows and
* image suites. Its methods use the existing private driver/runner; no raw
* credential enters options, receipts or the recovery record.
*/
export async function withControlApiFixtureRuntime(options, privateMaterial, work) {
const fence = await openControlApiCatalogIsolation(options)
const images = []
let memoryState = options.fixtureBinding ? 'created' : 'not-created'
let receiptFile = options.publicArguments?.['fixtures-receipt'], referenceOptions = options
let result, failure
const check = value => assert(value.profile === options.profile && value.context === options.context && value.runId === options.runId && value.prepare === 'restart',
'COORDINATOR_CATALOG_SCOPE_CHANGED')
const runtime = { initialSnapshot: fence.original,
async run(value) {
check(value); referenceOptions = value
if (value.prepareFixtures) memoryState = 'created-or-unknown'
else if (value.fixtureBinding) { memoryState = 'created'; receiptFile = value.publicArguments['fixtures-receipt'] }
const report = await seed(value, seedPrivateMaterial(privateMaterial))
if (value.prepareFixtures) { memoryState = 'created'; receiptFile = value.report }
return report
},
async journey(argumentsForRunner, value) {
check(value)
if (value.prepareFixtures) memoryState = 'created-or-unknown'
if (value.fixtureBinding) { memoryState = 'created'; receiptFile = value.publicArguments['fixtures-receipt']; referenceOptions = value }
const grantStatus = { state: 'not-created', bindings: [] }; images.push(grantStatus)
const report = await coordinate(argumentsForRunner, value, privateMaterial, { catalogFence: fence, grantStatus })
if (value.prepareFixtures) { memoryState = 'created'; receiptFile = value.report; referenceOptions = value }
return report
},
async proxyMemory(runId, value, work) {
check(value)
assert(memoryState === 'created' && value.prepareFixtures !== true && value.fixtureBinding &&
value.publicArguments?.['fixtures-receipt'] === receiptFile && typeof work === 'function' &&
/^subscription-image-[a-f0-9]{12}$/.test(runId) && images.length === 4 &&
images.every(status => status.state === 'revoked'), 'COORDINATOR_LIVE_PROXY_FIXTURE_REQUIRED')
referenceOptions = value
const grantStatus = { state: 'not-created', bindings: [] }; images.push(grantStatus)
// Resume the same owned memory run/UIDs while the original cron fence is
// active. The registered image status participates in outer restoration.
return seed(value, seedPrivateMaterial(privateMaterial), async session =>
withImageQaSession(session, runId, grantStatus, qa => work({ session, qa,
qaState: () => ({ state: grantStatus.state, bindings: structuredClone(grantStatus.bindings) }) })))
},
}
try { result = await work(runtime) } catch (error) { failure = error }
finally {
if (memoryState === 'created' && receiptFile) {
try {
const released = await seed(releaseOptionsForQa(referenceOptions, receiptFile), seedPrivateMaterial(privateMaterial), async session => session.revokeMemory())
assert(released.kind === 'control-api-authorize-qa-finalization.v1' && released.fixtureFinalization?.verified === true &&
released.fixtureFinalization.state === 'revoked' && released.fixtureFinalization.grantsRevoked === 2 &&
released.fixtureFinalization.hostsDetached === 2, 'COORDINATOR_MEMORY_QA_FINALIZATION_UNPROVED')
memoryState = 'revoked'
} catch (error) { failure ??= error }
}
const restoreSafe = catalogRestorationSafe(memoryState, images)
if (restoreSafe) {
try { await restoreDeployments(options.context, [fence]) } catch (error) { failure ??= error }
} else {
// Keep both actual cron overrides false: connected opaque QA can be
// touched by Control API's direct first cron tick, outside vendor hooks.
try {
writeCatalogRecovery(path.join(path.dirname(options.report), `${options.runId}-catalog-recovery.json`),
fence, options, memoryState, images)
} catch (error) { failure ??= error }
failure ??= new Error('COORDINATOR_CATALOG_RESTORE_BLOCKED_BY_QA')
}
}
if (failure) throw new Error(/^[A-Z0-9_]+$/.test(failure.message) ? failure.message : 'COORDINATOR_CATALOG_SCOPE_FAILED')
return result
}
export function catalogRestorationSafe(memoryState, images) {
return ['not-created', 'revoked'].includes(memoryState) &&
images.every(value => ['not-created', 'revoked'].includes(value.state))
}
function writeCatalogRecovery(filename, fence, options, memoryState, images) {
const directory = path.dirname(filename), stat = fs.lstatSync(directory)
assert(stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === process.getuid?.() && !(stat.mode & 0o077) &&
fs.realpathSync(directory) === directory, 'COORDINATOR_RECOVERY_DIRECTORY_UNSAFE')
fs.writeFileSync(filename, JSON.stringify({ kind: 'evenfire-control-api-qa-catalog-isolation-v1',
profile: options.profile, context: options.context, runId: options.runId,
deploymentUid: fence.original.uid, imageId: fence.baseImageId, initialControlledEnv: fence.original.env,
retainedControlledEnv: fence.applied.env, memoryQaState: memoryState,
imageQa: images.map(value => ({ state: value.state, bindings: value.bindings })),
reason: 'CATALOG_CRONS_REMAIN_FALSE_UNTIL_ALL_OWNED_QA_REVOCATIONS_VERIFIED', recordedAt: new Date().toISOString(),
}), { flag: 'wx', mode: 0o600 })
}
export function verifyQaModelProjection(configMap, binding) {
const bound = binding.provider === 'grok-subscription' ? projection.toEligibleGrokPolicyBinding : projection.toEligiblePolicyBinding
const models = JSON.parse(configMap.data?.[binding.provider] ?? '[]')
for (const [model, expected] of [[binding.modelId, 'supported'], [binding.unsupportedModelId, 'unsupported'],
[binding.fallback.modelId, 'supported']]) {
const eligible = bound(configMap, binding.connectionKey, model)
const matches = models.filter(value => value.model === model)
assert(eligible.binding?.credentialRevision === binding.credentialRevision &&
eligible.binding.catalogRevision === binding.catalogRevision && matches.length === 1 &&
imageCapability.resolveImageInputCapability(matches[0].imageInput, { transportSupported: true }).state === expected,
'COORDINATOR_ACTUAL_MODEL_ELIGIBILITY_UNPROVED')
}
assert(binding.fallback.provider === binding.provider && binding.fallback.modelId !== binding.modelId &&
binding.fallback.modelId !== binding.unsupportedModelId, 'COORDINATOR_FALLBACK_GRANT_INVALID')
return true
}
// The actual import publishes its own allowlisted witness. This reader returns
// only that witness and the append-only ledger; no process environment/argv,
// credentials, request body or diagnostic output is read.
export const VENDOR_OBSERVATION_PROGRAM = String.raw`
const fs=require('node:fs');let raw='';
process.stdin.on('data',chunk=>{raw+=chunk;if(raw.length>65536)process.exit(1)});
process.stdin.on('end',()=>{try{
const input=JSON.parse(raw);
const read=file=>{const stat=fs.lstatSync(file);if(!stat.isFile()||stat.isSymbolicLink()||stat.nlink!==1||
(stat.mode&511)!==384||stat.uid!==process.getuid()||stat.size>4*1024*1024)throw Error('VENDOR_RECORD_INVALID');
return JSON.parse(fs.readFileSync(file,'utf8'))};
const witness=read(input.evidencePath+'.runtime.json');
if(witness.pid!==Number(witness.pid)||!Number.isSafeInteger(witness.pid)||witness.pid<1||
fs.readFileSync('/proc/'+witness.pid+'/stat','utf8').split(') ')[1].split(' ')[19]!==witness.startTime)throw Error('VENDOR_PROCESS_CHANGED');
process.stdout.write(JSON.stringify({witness,ledger:read(input.evidencePath)}));
}catch{process.exitCode=1}});`
async function activateVendors({ contextDir, source, memoryOptions, qa, runId, states }) {
const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'deploy/minikube/.image-manifest.json'), 'utf8'))
assert(manifest.profile === memoryOptions.profile, 'COORDINATOR_IMAGE_MANIFEST_PROFILE')
const hostRef = 'clerum/mcp-host:test', hostId = manifest.images[hostRef]
assert(validImageId(hostId) && manifest.sourceRevisions?.[hostRef] === source.gitHead,
'COORDINATOR_EXACT_MUSL_HOST_IMAGE_REQUIRED')
const sources = {}
for (const provider of PROVIDERS) {
const name = `${provider.startsWith('grok') ? 'grok' : 'codex'}-llm-proxy`
const resource = getDeployment(memoryOptions.context, name)
const names = ['NODE_ENV', 'NODE_OPTIONS', 'EVENFIRE_SUBSCRIPTION_IMAGE_VENDOR_FIXTURE',
'SUBSCRIPTION_IMAGE_FIXTURE_PROVIDER', 'SUBSCRIPTION_IMAGE_EVIDENCE_PATH', 'E2E_SUBSCRIPTION_IMAGE_RUN_ID',
'E2E_GROK_IMAGE_MODEL', 'E2E_GROK_IMAGE_UNSUPPORTED_MODEL', 'E2E_CODEX_IMAGE_MODEL', 'E2E_CODEX_IMAGE_UNSUPPORTED_MODEL']
const original = snapshotDeployment(resource, name, names)
const baseId = manifest.images[original.image] ?? manifest.images[`docker.io/${original.image}`]
const basePod = await until(() => readyPod(memoryOptions.context, name, original.uid), Boolean, 120_000,
'COORDINATOR_BASE_PROXY_NOT_READY')
assert(validImageId(baseId) && imageId(basePod.status.containerStatuses.find(value => value.name === name).imageID) === baseId &&
(manifest.sourceRevisions?.[original.image] ?? manifest.sourceRevisions?.[`docker.io/${original.image}`]) === source.gitHead,
'COORDINATOR_BASE_PROXY_SOURCE_MISMATCH')
const baseDist = command('kubectl', ['--context', memoryOptions.context, '-n', NAMESPACE, 'exec', basePod.metadata.name,
'-c', name, '--', 'env', '-u', 'NODE_OPTIONS', 'node', '-e',
"process.stdout.write(require('node:crypto').createHash('sha256').update(require('node:fs').readFileSync('dist/main.js')).digest('hex'))"],
{ timeout: 30_000 }).trim()
const fixtureTag = `clerum/${name}-image-qa:${runId.slice(-12)}`
const built = JSON.parse(command('bash', [path.join(ROOT, 'scripts/e2e/build-subscription-image-proxy.sh'),
memoryOptions.profile, contextDir, original.image, baseId, hostId, fixtureTag, source.gitHead], { timeout: 450_000 }))
assert(built.baseImageId === baseId && built.hostImageId === hostId && built.gitHead === source.gitHead &&
validImageId(built.imageId), 'COORDINATOR_DERIVED_BUILD_IDENTITY')
const env = { ...original.env, NODE_ENV: 'test', NODE_OPTIONS: [original.env.NODE_OPTIONS,
`--import=${IMPORT_PATH}`].filter(Boolean).join(' '), EVENFIRE_SUBSCRIPTION_IMAGE_VENDOR_FIXTURE: '1',
SUBSCRIPTION_IMAGE_FIXTURE_PROVIDER: provider,
SUBSCRIPTION_IMAGE_EVIDENCE_PATH: `/tmp/evenfire-vendor/${runId}-${provider}.json`, E2E_SUBSCRIPTION_IMAGE_RUN_ID: runId }
for (const binding of qa.bindings) {
const prefix = binding.provider.startsWith('grok') ? 'GROK' : 'CODEX'
env[`E2E_${prefix}_IMAGE_MODEL`] = binding.modelId
env[`E2E_${prefix}_IMAGE_UNSUPPORTED_MODEL`] = binding.unsupportedModelId
}
const applied = { image: fixtureTag, env }
const state = { name, original, applied, baseImageId: baseId, fixtureImageId: built.imageId,
gitHead: source.gitHead, changed: true, provider }; states.push(state)
patchDeployment(memoryOptions.context, name, deploymentMutationPatch(getDeployment(memoryOptions.context, name), original, applied))
command('kubectl', ['--context', memoryOptions.context, '-n', NAMESPACE, 'rollout', 'status', `deployment/${name}`, '--timeout=120s'],
{ timeout: 150_000 })
const pod = await until(() => readyPod(memoryOptions.context, name, original.uid), Boolean, 120_000,
'COORDINATOR_DERIVED_PROXY_NOT_READY')
const observation = json(memoryOptions.context, ['-n', NAMESPACE, 'exec', '-i', pod.metadata.name, '-c', name,
'--', 'env', '-u', 'NODE_OPTIONS', '-u', 'EVENFIRE_SUBSCRIPTION_IMAGE_VENDOR_FIXTURE',
'node', '-e', VENDOR_OBSERVATION_PROGRAM], JSON.stringify({ evidencePath: env.SUBSCRIPTION_IMAGE_EVIDENCE_PATH }))
const actual = observation.witness
assert(actual.kind === 'evenfire-subscription-image-vendor-runtime-v1' && actual.runId === runId && actual.provider === provider &&
/^24\./.test(actual.nodeVersion) && actual.musl === true && actual.nodeOptionsSha256 === digest(env.NODE_OPTIONS) &&
actual.importSha256 === digest(fs.readFileSync(path.join(contextDir, 'scripts/e2e/fixtures/subscription-image-provider.mjs'))) &&
actual.productionDistSha256 === baseDist, 'COORDINATOR_ACTUAL_IMPORT_OR_DIST_MISMATCH')
const physicalImageId = imageId(pod.status.containerStatuses.find(value => value.name === name).imageID)
assert(physicalImageId === built.imageId && physicalImageId !== baseId, 'COORDINATOR_DERIVED_IMAGE_UNPROVED')
const witness = { profile: memoryOptions.profile, gitHead: source.gitHead, podUid: pod.metadata.uid,
imageId: physicalImageId, fixtureImportSha256: actual.importSha256,
deploymentUid: original.uid, pid: actual.pid, processStartTime: actual.startTime,
productionDistSha256: baseDist, baseImageId: baseId, hostImageId: hostId }
Object.assign(state, { podName: pod.metadata.name, witness, env, runtimeWitness: actual })
sources[provider] = witness
}
return sources
}
function selectedFields(resource, original) {
assert(resource.metadata.uid === original.uid, 'COORDINATOR_DEPLOYMENT_OWNER_CHANGED')
const container = resource.spec.template.spec.containers.find(value => value.name === original.containerName)
const env = {}
for (const name of original.names) {
const values = (container.env ?? []).filter(value => value.name === name)
assert(values.length <= 1 && values.every(value => !value.valueFrom), 'COORDINATOR_RESTORE_ENV_AMBIGUOUS')
if (values.length) env[name] = values[0].value
}
return { image: container.image, env }
}
async function restoreDeployments(context, states) {
const failures = []
for (const state of [...states].reverse()) {
if (!state.changed) continue
try {
const current = getDeployment(context, state.name)
const wanted = { image: state.original.image, env: state.original.env }
if (!isDeepStrictEqual(selectedFields(current, state.original), wanted))
patchDeployment(context, state.name, deploymentMutationPatch(current, state.original, state.applied, true))
command('kubectl', ['--context', context, '-n', NAMESPACE, 'rollout', 'status', `deployment/${state.name}`, '--timeout=120s'],
{ timeout: 150_000 })
assert(isDeepStrictEqual(selectedFields(getDeployment(context, state.name), state.original), wanted),
'COORDINATOR_RESTORATION_UNPROVED')
const pod = await until(() => readyPod(context, state.name, state.original.uid), Boolean, 120_000, 'COORDINATOR_RESTORED_POD_UNREADY')
assert(imageId(pod.status.containerStatuses.find(value => value.name === state.name).imageID) === state.baseImageId,
'COORDINATOR_RESTORED_IMAGE_ID_CHANGED')
state.changed = false
} catch { failures.push(state.name) }
}
assert(failures.length === 0, 'COORDINATOR_RESTORATION_FAILED')
}
export async function * vendorFrames({ admission, states, loginFrame, remainingFrame, observe, signal }) {
yield Buffer.from(JSON.stringify(loginFrame) + '\n')
if (remainingFrame) yield Buffer.from(JSON.stringify(remainingFrame) + '\n')
const previous = new Map(PROVIDERS.map(provider => [provider, []]))
const hashes = new Map()
while (!signal.aborted) {
for (const state of states.filter(value => value.provider)) {
const observed = await observe(state)
const frame = { kind: 'evenfire-subscription-image-vendor-frame-v1', runId: admission.runId,
provider: state.provider, source: state.witness, ledger: observed.ledger }
const binding = admission.bindings.find(value => value.provider === state.provider)
admitVendorFrame(frame, admission.runId, binding, admission.vendorSources[state.provider], previous.get(state.provider))
const hash = digest(JSON.stringify(frame))
if (hash !== hashes.get(state.provider)) {
previous.set(state.provider, structuredClone(frame.ledger.attempts)); hashes.set(state.provider, hash)
yield Buffer.from(JSON.stringify(frame) + '\n')
}
}
if (!signal.aborted) await pause(50) // Receipt polling never advances UI.
}
}
export const PRESSURE_RELAY_PROGRAM = String.raw`
import fs from 'node:fs';import net from 'node:net';
const socketPath=process.argv[1];
if(!/^\/run\/evenfire-e2e\/pressure-[a-f0-9]{12}\.sock$/.test(socketPath)||fs.existsSync(socketPath))throw Error('RELAY_PATH_INVALID');
const pending=new Map(),sockets=new Set();let next=0,buffer='';
const server=net.createServer(socket=>{let raw='';sockets.add(socket);socket.requestBusy=false;
socket.on('data',chunk=>{raw+=chunk;if(raw.length>65536||socket.requestBusy){socket.destroy();return}
const end=raw.indexOf('\n');if(end<0)return;
const line=raw.slice(0,end);raw=raw.slice(end+1);if(raw){socket.destroy();return}
const callId=String(++next);pending.set(callId,socket);socket.requestBusy=true;socket.pause();
process.stdout.write(JSON.stringify({callId,input:JSON.parse(line)})+'\n');
});socket.on('close',()=>{sockets.delete(socket);for(const [id,value]of pending)if(value===socket)pending.delete(id)});
});
process.stdin.on('data',chunk=>{buffer+=chunk;if(buffer.length>65536)throw Error('RELAY_BOUND');
for(let end;(end=buffer.indexOf('\n'))>=0;){const frame=JSON.parse(buffer.slice(0,end));buffer=buffer.slice(end+1);
const socket=pending.get(frame.callId);if(!socket)throw Error('RELAY_UNKNOWN_REPLY');pending.delete(frame.callId);
socket.write(JSON.stringify(frame.data)+'\n');socket.requestBusy=false;socket.resume();
}});
process.stdin.on('end',()=>{for(const socket of sockets)socket.destroy();server.close(()=>{
if(fs.existsSync(socketPath))fs.unlinkSync(socketPath);process.exitCode=0})});
server.listen(socketPath,()=>{fs.chmodSync(socketPath,384);process.stdout.write(JSON.stringify({ready:true,socketPath})+'\n')});`
/** A broken relay must not bypass native request release or Channel shutdown. */
export async function closePressureResources(relay, pressure) {
const results = await Promise.allSettled([relay, pressure].map(resource =>
Promise.resolve().then(() => resource?.close())))
const failures = results.filter(value => value.status === 'rejected').map(value => value.reason)
if (failures.length) throw new AggregateError(failures, 'COORDINATOR_PRESSURE_RESTORATION_FAILED')
}
/** A successful runner does not authorize canonical vendor restoration. The
* actual seeder must first acknowledge both owned grant revocations/detaches.
*/
export async function withImageQaSession(session, runId, grantStatus, work) {
grantStatus.state = 'created-or-unknown'
try {
const qa = await session.prepareImages(runId)
grantStatus.state = 'created'
grantStatus.bindings = qa.bindings.map(({ provider, hostRef, hostUid, connectionKey, connectionId }) =>
({ provider, hostRef, hostUid, connectionKey, connectionId }))
return await work(qa)
} finally {
const restored = await session.revokeImages()
assert(restored.verified === true && (grantStatus.state !== 'created' ||
(restored.grantsRevoked === grantStatus.bindings.length && restored.hostsDetached === grantStatus.bindings.length)),
'COORDINATOR_QA_GRANT_RESTORATION_FAILED')
grantStatus.state = 'revoked'
}
}
export function qaRestorationTargets(grantState, states) {
return { restore: states.filter(state => !state.provider || grantState === 'revoked'),
retain: states.filter(state => state.provider && state.changed && grantState !== 'revoked') }
}
function writeQaRecovery(filename, grantStatus, states, options, runId) {
const directory = path.dirname(filename), stat = fs.lstatSync(directory)
assert(stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === process.getuid?.() &&
!(stat.mode & 0o077) && fs.realpathSync(directory) === directory, 'COORDINATOR_RECOVERY_DIRECTORY_UNSAFE')
fs.writeFileSync(filename, JSON.stringify({ kind: 'evenfire-subscription-image-qa-recovery-v1',
runId, profile: options.profile, context: options.context, recordedAt: new Date().toISOString(),
qaGrantState: grantStatus.state, qaBindings: grantStatus.bindings,
vendorsRetained: states.map(state => ({ provider: state.provider, name: state.name,
deploymentUid: state.original.uid, originalImageId: state.baseImageId, originalImage: state.original.image,
fixtureImageId: state.fixtureImageId, gitHead: state.gitHead,
originalControlledEnv: state.original.env, fixtureImage: state.applied.image,
fixtureControlledEnv: state.applied.env, witness: state.witness })),
canonicalRestore: 'BLOCKED_UNTIL_OWNED_GRANT_REVOCATION_VERIFIED',
}), { flag: 'wx', mode: 0o600 })
}
async function pressureRelay({ containerName, pressure, metadata, processIdentity }) {
const child = spawn('docker', ['exec', '-i', containerName, 'node', '--input-type=module', '-e', PRESSURE_RELAY_PROGRAM,
metadata.socketPath], { stdio: ['pipe', 'pipe', 'pipe'] })
child.stderr.resume(); child.stdout.setEncoding('utf8')
let buffer = '', chain = Promise.resolve(), failed, readyResolve, readyReject, accepting = true
const ready = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject })
const observation = value => ({ ok: true, pressureRunId: metadata.pressureRunId, maxInFlight: metadata.maxInFlight,
owners: { baseline: 0, held: value.inFlight, drained: value.inFlight },
counts: { sameRunAttempts: value.counts.total, sameRunTickets: value.counts.tickets, reservations: value.counts.reservationRows },
pids: [value.pid], inspector: { pid: value.pid, startTime: processIdentity.startTime } })
child.stdout.on('data', chunk => {
if (!accepting) return
buffer += chunk
if (Buffer.byteLength(buffer) > 65536) { failed = true; readyReject(new Error('PRESSURE_RELAY_BOUND')); child.kill('SIGTERM'); return }
for (let end; (end = buffer.indexOf('\n')) >= 0;) {
const line = buffer.slice(0, end); buffer = buffer.slice(end + 1)
chain = chain.then(async () => {
const frame = JSON.parse(line)
if (frame.ready === true) { assert(frame.socketPath === metadata.socketPath, 'PRESSURE_RELAY_PATH_CHANGED'); readyResolve(); return }
const input = frame.input
assert(input.pressureRunId === metadata.pressureRunId && ['hello', 'hold', 'owners', 'release', 'close'].includes(input.command),
'PRESSURE_RELAY_COMMAND_INVALID')
let value
if (input.command === 'hold') {
assert(input.maxInFlight === metadata.maxInFlight, 'PRESSURE_RELAY_POLICY_CHANGED')
value = await pressure.hold()
} else if (['release', 'close'].includes(input.command)) value = await pressure.release()
else value = await pressure.owners()
const data = observation(value)
if (input.command === 'hold') data.owners.drained = 0
child.stdin.write(JSON.stringify({ callId: frame.callId, data }) + '\n')
}).catch(() => { failed = true; readyReject(new Error('PRESSURE_RELAY_FAILED')); child.kill('SIGTERM') })
}
})
child.once('error', () => { failed = true; readyReject(new Error('PRESSURE_RELAY_START_FAILED')) })
const exited = new Promise(resolve => child.once('close', (code, signal) => {
if (code !== 0 || signal) { failed = true; readyReject(new Error('PRESSURE_RELAY_PRODUCER_FAILED')) }
resolve({ code, signal })
}))
const timer = setTimeout(() => { readyReject(new Error('PRESSURE_RELAY_READY_TIMEOUT')); child.kill('SIGTERM') }, 30_000)
try { await ready } finally { clearTimeout(timer) }
let closing
return { assertHealthy: () => assert(!failed, 'PRESSURE_RELAY_PRODUCER_FAILED'),
close: () => closing ??= (async () => {
accepting = false
await chain; child.stdin.end()
const timer = setTimeout(() => child.kill('SIGKILL'), 10_000)
const result = await exited; clearTimeout(timer)
assert(!failed && result.code === 0 && !result.signal, 'PRESSURE_RELAY_PRODUCER_FAILED')
})() }
}
export async function coordinate(prepareArguments, memoryOptions, privateMaterial, catalogRuntime) {
assert(process.versions.node.startsWith('24.') && fs.realpathSync(process.cwd()) === ROOT, 'COORDINATOR_NODE24_WORKTREE_REQUIRED')
assert(memoryOptions.prepareFixtures === true || memoryOptions.fixtureBinding, 'COORDINATOR_ISOLATED_OPERATOR_REQUIRED')
validatePrivateControlMaterial(privateMaterial)
validateMemoryOperatorSelection(memoryOptions)
assert(memoryOptions.prepare === 'restart', 'COORDINATOR_RECONCILED_BASELINE_REQUIRED')
const values = Object.fromEntries(Array.from({ length: prepareArguments.length / 2 }, (_, index) =>
[prepareArguments[index * 2].slice(2), prepareArguments[index * 2 + 1]]))
assert(values.mode === 'fixture' && values.profile === memoryOptions.profile && /^subscription-image-[a-f0-9]{12}$/.test(values['run-id'] ?? '') &&
values.frames === '-' && !values.bindings && path.isAbsolute(values.scratch), 'COORDINATOR_PUBLIC_ARGUMENTS_INVALID')
const suite = resolveSuite(values.suite)
command('bash', [path.join(ROOT, 'scripts/minikube/require-t2-mutation-lock.sh')], { timeout: 10_000 })
const states = [], abort = new AbortController()
const grantStatus = catalogRuntime?.grantStatus ?? { state: 'not-created', bindings: [] }
let catalogFence = catalogRuntime?.catalogFence, memoryState = memoryOptions.fixtureBinding ? 'created' : 'not-created'
let result, failure, relay, pressure
let pressureClosing
const closePressure = () => pressureClosing ??= closePressureResources(relay, pressure)
const onSignal = () => abort.abort(new Error('COORDINATOR_INTERRUPTED'))
process.once('SIGINT', onSignal); process.once('SIGTERM', onSignal)
try {
if (!catalogFence) catalogFence = await openControlApiCatalogIsolation(memoryOptions)
if (values.suite === 'admission-recovery') {
const resource = getDeployment(memoryOptions.context, 'control-api')
const original = snapshotDeployment(resource, 'control-api', ['NODE_OPTIONS'])
const basePod = await until(() => readyPod(memoryOptions.context, 'control-api', original.uid), Boolean, 120_000,
'COORDINATOR_BASE_API_NOT_READY')
const baseImageId = imageId(basePod.status.containerStatuses.find(value => value.name === 'control-api').imageID)
assert(validImageId(baseImageId), 'COORDINATOR_BASE_API_IMAGE_UNKNOWN')
const applied = { image: original.image, env: { NODE_OPTIONS:
`--max-old-space-size=${memoryOptions.candidate.heapSizeMiB} --inspect=127.0.0.1:${memoryOptions.inspectorPort}` } }
const state = { name: 'control-api', original, applied, baseImageId, changed: true }; states.push(state)
patchDeployment(memoryOptions.context, state.name, deploymentMutationPatch(resource, original, applied))
command('kubectl', ['--context', memoryOptions.context, '-n', NAMESPACE, 'rollout', 'status', 'deployment/control-api', '--timeout=120s'],
{ timeout: 150_000 })
}
if (memoryOptions.prepareFixtures) memoryState = 'created-or-unknown'
await seed(memoryOptions, seedPrivateMaterial(privateMaterial), async session => {
memoryState = 'created'
await withImageQaSession(session, values['run-id'], grantStatus, async qa => {
assert(qa.credentialState === 'opaque-qa-not-real-G8' && qa.vendorCronsDisabled === true &&
qa.operatorDesktopUserId === session.fixtures.operatorDesktopUserId && qa.operatorDesktopUserId !== session.fixtures.operatorId,
'COORDINATOR_DESKTOP_OPERATOR_UNPROVED')
const configMap = json(memoryOptions.context, ['-n', memoryOptions.hostNamespace, 'get', 'configmap',
'clerum-llm-allowed-models', '-o', 'json'])
for (const binding of qa.bindings) verifyQaModelProjection(configMap, binding)
let closed = false, remainingFrame
const flow = { bindings: qa.bindings.map(({ provider, hostRef, hostLabel, modelId, modelLabel,
unsupportedModelId, unsupportedModelLabel }) => ({ provider, hostRef, hostLabel, modelId, modelLabel,
unsupportedModelId, unsupportedModelLabel })),
async beforeBuild(input) {
flow.vendorSources = await activateVendors({ ...input, memoryOptions, qa, runId: values['run-id'], states })
},
async configure(admission, { containerName }) {
let metadata
if (admission.suiteId === 'admission-recovery') {
const child = spawn('kubectl', ['--context', memoryOptions.context, '-n', NAMESPACE, 'exec', '-i', session.apiPod.name,
'-c', 'control-api', '--', 'env', '-u', 'NODE_OPTIONS', 'node', '--max-old-space-size=64',
'--input-type=module', '-e', buildAuthorizeMemoryCompanionBundle()], { cwd: ROOT, stdio: ['pipe', 'pipe', 'pipe'] })
pressure = await openAuthorizeAdmissionPressure(new Channel(child, pressureCommandDeadlineMs(memoryOptions.candidate)), {
candidate: memoryOptions.candidate, inspectorPort: memoryOptions.inspectorPort,
runId: `pr806-memory-${admission.runId.slice(-12)}`, hostNamespace: memoryOptions.hostNamespace,
bindings: qa.bindings.map(value => ({ hostRef: value.hostRef, hostUid: value.hostUid })) })
const owner = await pressure.owners()
const processIdentity = json(memoryOptions.context, ['-n', NAMESPACE, 'exec', '-i', session.apiPod.name,
'-c', 'control-api', '--', 'env', '-u', 'NODE_OPTIONS', 'node', '-e',
"let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{const pid=JSON.parse(s).pid;const startTime=require('node:fs').readFileSync('/proc/'+pid+'/stat','utf8').split(') ')[1].split(' ')[19];process.stdout.write(JSON.stringify({pid,startTime}))})"],
JSON.stringify({ pid: owner.pid }))
metadata = { kind: 'evenfire-subscription-image-pressure-metadata-v1', profile: admission.profile,
context: admission.context, worktreeId: admission.stack.worktreeId,
sourceManifestSha256: admission.sourceManifestSha256, podUid: session.apiPod.uid,
imageId: session.apiPod.imageId, pressureRunId: `subscription-image-pressure-${admission.runId.slice(-12)}`,
hostRefs: qa.bindings.map(value => value.hostRef), maxInFlight: memoryOptions.candidate.concurrency,
readDeadlineMs: pressure.policy.readDeadlineMs, workDeadlineMs: pressure.policy.workDeadlineMs,
closeGraceMs: pressure.policy.closeGraceMs, commandDeadlineMs: pressure.commandDeadlineMs,
socketPath: `${RUNNER_RUN_BASE}/pressure-${admission.runId.slice(-12)}.sock` }
relay = await pressureRelay({ containerName, pressure, metadata, processIdentity })
}
if (suite.fixtureReceiptEnv) {
const prepared = await prepareRemainingFixtures({ admission, runRoot: `${RUNNER_RUN_BASE}/${admission.runId}`,
hostBindings: qa.bindings,
prepareGfs: input => session.prepareGfs({ ...input, userId: qa.operatorDesktopUserId,
parentResourceId: session.fixtures.gfs.parentResourceId }),
pressure: metadata && { ...metadata,
receiptFile: '/runner-admission/main-admission.json' } })
remainingFrame = prepared.frame
}
return metadata ? { pressureMetadata: metadata } : undefined
},
frames(admission) {
const loginFrame = Object.fromEntries([['kind', 'evenfire-subscription-image-login-v1'],
['runId', admission.runId], ['email', qa.loginEmail], ['password', desktopPasswordFor(privateMaterial)]])
return Readable.from(vendorFrames({ admission, states, remainingFrame, loginFrame, signal: abort.signal,
observe: state => {
relay?.assertHealthy()
const current = readyPod(memoryOptions.context, state.name, state.original.uid)
assert(current?.metadata?.uid === state.witness.podUid &&
imageId(current.status.containerStatuses.find(value => value.name === state.name).imageID) === state.witness.imageId,
'COORDINATOR_VENDOR_POD_CHANGED')
const observed = json(memoryOptions.context, ['-n', NAMESPACE, 'exec', '-i', state.podName, '-c', state.name,
'--', 'env', '-u', 'NODE_OPTIONS', '-u', 'EVENFIRE_SUBSCRIPTION_IMAGE_VENDOR_FIXTURE', 'node', '-e', VENDOR_OBSERVATION_PROGRAM],
JSON.stringify({ evidencePath: state.env.SUBSCRIPTION_IMAGE_EVIDENCE_PATH }))
assert(isDeepStrictEqual(observed.witness, state.runtimeWitness), 'COORDINATOR_VENDOR_SOURCE_CHANGED')
return observed
} }), { objectMode: false, highWaterMark: 64 * 1024 })
},
async close() {
if (closed) return
closed = true; abort.abort()
await closePressure()
},
}
result = await prepare(prepareArguments, flow)
assert(result === 0 && !abort.signal.reason?.message?.includes('INTERRUPTED'), 'COORDINATOR_RUNNER_FAILED')
})
})
} catch (error) { failure = error }
finally {
abort.abort()
try { await closePressure() } catch (error) {
failure = failure ? new AggregateError([failure, error], 'COORDINATOR_OPERATION_AND_CLEANUP_FAILED') : error
}
const targets = qaRestorationTargets(grantStatus.state, states)
try { await restoreDeployments(memoryOptions.context, targets.restore) } catch (error) {
failure = failure ? new AggregateError([failure, error], 'COORDINATOR_OPERATION_AND_CLEANUP_FAILED') : error
}
if (targets.retain.length) {
try {
writeQaRecovery(path.join(path.dirname(memoryOptions.report), `${values['run-id']}-qa-recovery.json`),
grantStatus, targets.retain, memoryOptions, values['run-id'])
} catch (error) {
failure = failure ? new AggregateError([failure, error], 'COORDINATOR_OPERATION_AND_CLEANUP_FAILED') : error
}
failure ??= new Error('COORDINATOR_CANONICAL_VENDOR_RESTORE_BLOCKED')
}
if (catalogFence && !catalogRuntime) {
if (memoryState === 'not-created' && ['not-created', 'revoked'].includes(grantStatus.state)) {
try { await restoreDeployments(memoryOptions.context, [catalogFence]) } catch (error) { failure ??= error }
} else {
try { writeCatalogRecovery(path.join(path.dirname(memoryOptions.report), `${values['run-id']}-catalog-isolation.json`),
catalogFence, memoryOptions, memoryState, [grantStatus]) } catch (error) { failure ??= error }
}
}
process.off('SIGINT', onSignal); process.off('SIGTERM', onSignal)
}
if (failure) throw new Error(/^[A-Z0-9_]+$/.test(failure.message) ? failure.message : 'COORDINATOR_FAILED')
return { kind: 'evenfire-subscription-image-coordinator-v1', producerExit: result,
vendorBoundary: 'derived-external-fetch-only', restoration: { verified: true, scope: 'vendor-images-and-inspector' },
catalogIsolation: { retainedForMemoryFixtures: memoryState === 'created',
...(catalogFence ? { initialSnapshot: catalogFence.original } : {}) }, realOAuthOrG8: 'NOT_RUN' }
}
async function main() {
const argv = process.argv.slice(2)
const index = argv.indexOf('--memory-config')
assert(index >= 0 && argv[index + 1], 'COORDINATOR_MEMORY_CONFIG_REQUIRED')
const [, filename] = argv.splice(index, 2)
const memoryOptions = parseOptions(['--config', filename])
let bytes = Buffer.alloc(0), material
for await (const chunk of process.stdin) {
bytes = Buffer.concat([bytes, chunk]); assert(bytes.length <= 64 * 1024, 'COORDINATOR_PRIVATE_INPUT_BOUND')
const end = bytes.indexOf(10)
if (end < 0) continue
assert(end === bytes.length - 1, 'COORDINATOR_ONE_PRIVATE_INPUT_REQUIRED')
material = JSON.parse(bytes.toString('utf8')); bytes.fill(0); bytes = Buffer.alloc(0); break
}
assert(material?.kind === 'evenfire-subscription-image-private-control-v1', 'COORDINATOR_PRIVATE_INPUT_REQUIRED')
const privateMaterial = Object.fromEntries(['operatorPassword', 'cookie', 'desktopPassword'].filter(field => material[field] !== undefined)
.map(field => [field, material[field]]))
material = undefined
const result = await coordinate(argv, memoryOptions, privateMaterial)
for (const field of Object.keys(privateMaterial)) delete privateMaterial[field]
process.stdout.write(JSON.stringify(result) + '\n')
}
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
main().catch(() => { process.stderr.write('SUBSCRIPTION_IMAGE_COORDINATOR_FAILED\n'); process.exitCode = 1 })