// Started with fork() by the trusted host; boot refs/capabilities travel over IPC, // never command arguments, stdout or service-token-bearing environment variables. import { startBroker } from './runtime.mjs'; import { BusError } from './broker.mjs'; const LAUNCH_OPS = new Set([ 'identity', 'authorizeLaunch', 'refuse', 'endLaunch', 'recoverLaunch', 'credentialStatus', 'modelPreflight', 'modelStall', 'checkPush', 'recordPush', 'reviewFetch', 'checkLand', 'recordLand', 'landRefused', 'checkPublish', 'publishPush', 'publishResult', 'recordPublish', 'publishRefused', 'landHeld', 'threadsState', 'threadIdle', 'mayLaunch', 'landHolders', 'landRelease', 'lifecycleRequests', 'lifecycleTake', 'lifecycleDelete', 'lifecycleDone', 'sessionClears', 'sessionClearExited', 'sessionClearUncertain', 'sessionClearRetire', 'sessionClearStart', 'request.admission', 'request.launches', 'request.launchResult', 'request.release', 'request.chief', 'request.manifest', ]); function launchOp(m) { if (m.op === 'identity') return runtime.identity(m.cap); if (m.op === 'authorizeLaunch') return runtime.authorizeLaunch(m.cap, m.instance); if (m.op === 'refuse') return runtime.refuse(m.cap, m.code, m.subject); if (m.op === 'endLaunch') return runtime.endLaunch(m.record); if (m.op === 'recoverLaunch') return runtime.recoverLaunch(m.record); // Row 93 (#1587): the git socket's ops. if (m.op === 'checkPush') return runtime.checkPush(m.cap, m.task_ref, m.project); if (m.op === 'recordPush') return runtime.recordPush(m.cap, m.push); if (m.op === 'reviewFetch') return runtime.reviewFetch(m.cap, m.args); // Row 137 (#1631): the git socket's land op, and the launcher's question whether to bind it. if (m.op === 'checkLand') return runtime.checkLand(m.cap, m.args); if (m.op === 'recordLand') return runtime.recordLand(m.ticket, m.land); if (m.op === 'landRefused') return runtime.landRefused(m.ticket, m.args); // Row 199 (#1697, design D9b): the git socket's publish op. No entry returns a token. if (m.op === 'checkPublish') return runtime.checkPublish(m.cap, m.args); if (m.op === 'publishPush') return runtime.publishPush(m.ticket); if (m.op === 'publishResult') return runtime.publishResult(m.ticket); if (m.op === 'recordPublish') return runtime.recordPublish(m.ticket, m.pushed); if (m.op === 'publishRefused') return runtime.publishRefused(m.ticket, m.args); if (m.op === 'landHeld') return runtime.landHeld(m.record); // Row 121 (#1615): the launcher's view of the business's threads, and its idle release. if (m.op === 'threadsState') return runtime.threadsState(m.business); if (m.op === 'threadIdle') return runtime.threadIdle(m.record); // Row 125 (#1619, REQ-LIMIT-4): the limit checks' answer before a launch (async). if (m.op === 'mayLaunch') return runtime.mayLaunch(m); // Row 156 (#1651): the launcher's landing pass: who holds a merge decision, and the stop of a // role run started before its decision was resolved. if (m.op === 'landHolders') return runtime.landHolders(m.business); if (m.op === 'landRelease') return runtime.landRelease(m.record); // Row 194 (#1692, D1.1): the launcher's lifecycle pass. if (m.op === 'lifecycleRequests') return runtime.lifecycleRequests(m.business); if (m.op === 'lifecycleTake') return runtime.lifecycleTake(m.record); if (m.op === 'lifecycleDelete') return runtime.lifecycleDelete(m.record); if (m.op === 'lifecycleDone') return runtime.lifecycleDone(m.record); // Row 271 (264d, #1776, D7 steps 3-5): the launcher's clear pass. if (m.op === 'sessionClears') return runtime.sessionClears(m.business); if (m.op === 'sessionClearExited') return runtime.sessionClearExited(m.record); if (m.op === 'sessionClearUncertain') return runtime.sessionClearUncertain(m.record); if (m.op === 'sessionClearRetire') return runtime.sessionClearRetire(m.record); if (m.op === 'sessionClearStart') return runtime.sessionClearStart(m.record); // Lifecycle Task 2 (#797): may the launcher clone this project's code checkout. Scoped to the one // business and project named; a malformed ask answers launch-op-refused, never ready. if (m.op === 'request.launches') return runtime.requestLaunches(m.business); if (m.op === 'request.launchResult') return runtime.requestLaunchResult(m.record); if (m.op === 'request.release') return runtime.requestRelease(m.cap, m.record); if (m.op === 'request.manifest') return runtime.requestManifest(m.record); if (m.op === 'request.chief') return runtime.requestChief(m.business); if (m.op === 'request.admission') return runtime.admission({ business: m.business, project: m.project }); if (m.op === 'credentialStatus') return runtime.credentialStatus(m.business, m.role); if (m.op === 'modelPreflight') return runtime.modelPreflight(m); if (m.op === 'modelStall') return runtime.modelStall(m); // Every LAUNCH_OPS name has its line above. A missing one used to answer as credentialStatus, // whose [] for an unknown role read as "no holders" for landHolders (row 156 mutant P02). throw new BusError('launch-op-refused'); } // The host's request id comes back on the reply, so a late reply can't // answer a later request (host.mjs). A message without one gets none. const tag = (message, reply) => (Number.isSafeInteger(message?.id) ? { ...reply, id: message.id } : reply); let runtime, booted = false, closing = false; async function close(code) { if (closing) return; closing = true; try { await runtime?.close(); } catch { code = 2; } process.exitCode = code; if (process.connected) process.disconnect(); } if (!process.send) { process.stderr.write('trusted-host-required\n'); process.exitCode = 2; } else { const timer = setTimeout(() => close(2), 10000); process.on('message', async (message) => { try { if (message?.op === 'bindLaunch' && runtime) { try { process.send(tag(message, { ok: true, launch: runtime.bindLaunch(message.record) })); } catch (e) { process.send(tag(message, { ok: false, error: e instanceof BusError ? e.code : 'bind-refused' })); } return; } // S6 launcher ops, one reply each, like bindLaunch. if (LAUNCH_OPS.has(message?.op) && runtime) { try { process.send(tag(message, { ok: true, result: await launchOp(message) })); } catch (e) { process.send(tag(message, { ok: false, error: e instanceof BusError ? e.code : 'launch-op-refused' })); } return; } if (message?.op === 'close') { clearTimeout(timer); await close(0); return; } if (message?.op !== 'boot' || booted) throw new BusError('invalid-host-request'); booted = true; clearTimeout(timer); // `trackers` is S3's plain-data boot config; the adapter is loaded only when a business has one. // Row 199: publishTls is the tests' scratch CA, for an in-process runtime only. The host's boot // config never carries it, so a boot that does is refused rather than trusted. const { trackers, ...config } = message.config ?? {}; if (Object.hasOwn(config, 'publishTls')) throw new BusError('invalid-host-request'); if (trackers) { const { tasksAdapter } = await import('../../tasks/src/adapter.mjs'); config.tasks = tasksAdapter({ trackers }); } // The adapter above and the host's new-project preparation each read the tracker settings; only the adapter is built here. runtime = await startBroker({ ...config, ...(trackers ? { trackers } : {}) }); if (closing) { await runtime.close(); return; } process.send({ ok: true, path: runtime.path, launches: runtime.launches, readers: runtime.readers }); } catch (e) { process.send?.(tag(message, { ok: false, error: e instanceof BusError ? e.code : 'startup-refused' }), () => close(2), ); } }); process.on('disconnect', () => close(2)); process.on('SIGTERM', () => close(0)); process.on('SIGINT', () => close(0)); }