/** Explicit operator process only. No HTTP, runtime import, role provisioning or READY. */ import assert from 'node:assert/strict' import path from 'node:path' import {pathToFileURL} from 'node:url' import {createPrivateKey,createPublicKey,sign} from 'node:crypto' import {readdir} from 'node:fs/promises' import {readProtected,protectedDirectory,sha,withJournalLease,writeFile} from './writer-profile/operator-files.mjs' import {approval,upgradeApproval,reconciliationApproval,poolOptions,roleKeys,assertJsDriverEnvironment} from './writer-profile/operator-contract.mjs' import {deploymentRequest} from './database-writer-bootstrap-operator.mjs' const hex=(v:unknown)=>typeof v==='string'&&/^[a-f0-9]{64}$/.test(v) const parse=(b:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(b)) const sourceCommands=['source-activate','source-revoke','source-status'] export async function main(args:string[]){ if(args[0]==='legacy-cold-verify')return (await import('./writer-profile/legacy-cold-verification.mjs')).verifyLegacyColdMain(args) if(args[0]==='source58-foundation-enroll'||args[0]==='source57-admission-enroll')return (await import('./writer-profile/source58-foundation.mjs')).source58FoundationMain(args) if(args[0]==='legacy-control-reference'||args[0]==='legacy-source58-preflight')return (await import('./writer-profile/legacy-control-reference.mjs')).legacyControlReferenceMain(args) if(['legacy-handoff-execute','legacy-handoff-adopt','legacy-handoff-release'].includes(args[0]))return (await import('./writer-profile/legacy-handoff-execution.mjs')).legacyHandoffExecuteMain(args) if(['registry-enroll','registry-inspect','restore-profile-enroll'].includes(args[0]))return (await import('./writer-profile/registry-enrollment.mjs')).registryEnrollmentMain(args) if(args[0]==='marker-fence-enroll')return (await import('./writer-profile/marker-fence-enrollment.mjs')).markerFenceEnrollmentMain(args) if(sourceCommands.includes(args[0]))return (await import('./writer-profile/source-activation.mjs')).sourceActivationMain(args) if(['maintenance-inspect','maintenance-resolve'].includes(args[0]))return (await import('./writer-profile/maintenance-resolution.mjs')).maintenanceMain(args) const legacyCustody=args[0]==='legacy-custody' const legacyHandoff=args[0]==='legacy-handoff-inspect' const legacyExport=legacyCustody||args[0]==='legacy-export' const legacyInspection=legacyExport||legacyHandoff||args[0]==='legacy-inspect' const catalogueInspection=args[0]==='source-catalogue-inspect' const activePreflight=args[0]==='source-preflight',preflight=activePreflight||args[0]==='preflight' const upgrade=args[0]==='upgrade' const writes=upgrade||args[0]==='publish' const flags=['bootstrap','bootstrap-sha256','transport','transport-sha256','ca','source-registry','source-spki-sha256'] if(!legacyInspection)flags.push('definition','definition-sha256') if(!legacyInspection&&!catalogueInspection)flags.push('approval','approval-sha256','journal') if(legacyInspection||catalogueInspection||activePreflight||writes)flags.push('activation-directory','activation-sha256') if(legacyExport)flags.push('archive-directory','source-signing-key') if(legacyHandoff)flags.push('archive-directory','handoff-intent-sha256') assert((legacyInspection||catalogueInspection||preflight||writes||args[0]==='reconcile')&&args.length===1+2*flags.length) assertJsDriverEnvironment(process.env) const values=new Map() for(let i=1;ivalues.get(name)! for(const flag of flags.filter(f=>f.endsWith('sha256')))assert(hex(get(flag))) const bootstrap=parse(await readProtected(get('bootstrap'),32768,get('bootstrap-sha256'))) assert(bootstrap.format==='application-writer-bootstrap-v1'&&bootstrap.publicationAuthorized===false&&bootstrap.readyAuthorized===false) const request=deploymentRequest(bootstrap.deploymentRequest),subject=bootstrap.verificationSubject assert(subject.installationId===request.installationId&&hex(subject.publicKeySpkiSha256)&&sha(createPublicKey(subject.publicKeyPem).export({format:'der',type:'spki'}))===subject.publicKeySpkiSha256) const pinned=legacyInspection||catalogueInspection?undefined:(args[0]==='reconcile'?reconciliationApproval:upgrade?upgradeApproval:approval)(parse(await readProtected(get('approval'),16384,get('approval-sha256')))) const definition=legacyInspection?undefined:parse(await readProtected(get('definition'),4194304,get('definition-sha256'))) const transport=parse(await readProtected(get('transport'),16384,get('transport-sha256'))) const ca=await readProtected(get('ca'),65536,request.tls.caSha256) const options=poolOptions(transport,request,ca) if(!legacyInspection&&!catalogueInspection)await protectedDirectory(get('journal')) await protectedDirectory(get('source-registry')) const privateKeyFile=path.join(path.dirname(get('bootstrap')),'signing-private.pem') if(writes){const key=await readProtected(privateKeyFile,8192);key.fill(0)} // All explicit trust files are checked before app helper/PG imports. No .env URL is used. // Existing source helper loads config/dotenv. Complete it BEFORE pg's first // import so a newly loaded NODE_PG_FORCE_NATIVE cannot select another driver. const {createProtectedDatabaseSourceBindingVerifier}=await import('./writer-profile/protected-source-registry.mjs') assertJsDriverEnvironment(process.env) const [{default:pg},{createConnectedPublisher,requireCurrentCatalogueDefinition},{collectSource44Catalogue,collectSource56Catalogue,collectSource57Catalogue,collectSource58Catalogue,approvedDefinition}]=await Promise.all([ import('pg'),import('./writer-profile/publisher.mjs'),import('./writer-profile/catalogue.mjs')]) assertJsDriverEnvironment(process.env) const reviewedDefinition=legacyInspection?undefined:approvedDefinition(definition) const collectCatalogues={44:collectSource44Catalogue,56:collectSource56Catalogue,57:collectSource57Catalogue,58:collectSource58Catalogue} const collectCatalogue=collectCatalogues[reviewedDefinition&&'edition' in reviewedDefinition?reviewedDefinition.edition:44] if(!legacyInspection&&!catalogueInspection){ assert.equal(reviewedDefinition!.definitionSha256,pinned!.definitionSha256) if(args[0]!=='reconcile')requireCurrentCatalogueDefinition(pinned,reviewedDefinition) } const installation=Object.freeze({...subject,roles:Object.fromEntries(roleKeys.map(k=>[k,request.roles[k].signedOid])),roleBindings:request.roles,expectedSource:request.source,tls:Object.freeze({...request.tls})}) const sourcePin={registryDirectory:get('source-registry'),installationId:subject.installationId,publicKeySpkiSha256:get('source-spki-sha256'),currentHeadSha256:request.sourceHeadSha256} const archiveDirectory=legacyExport?get('archive-directory'):undefined let handoff if(legacyHandoff){ const {verifyLegacyProbeHandoffIntent}=await import('../src/services/server-probe-legacy-handoff-inspection.js') const directory=get('archive-directory'),maximum=64*1024*1024 const [archive,signedApproval,coldArchive,intent,operatorPublicKeyPem]=await Promise.all([ readProtected(path.join(directory,'legacy-probe.dump'),maximum),readProtected(path.join(directory,'legacy-probe-approval.json'),4096), readProtected(path.join(directory,'legacy-probe-cold.dump'),maximum), readProtected(path.join(directory,'legacy-probe-handoff-intent.json'),4096,get('handoff-intent-sha256')), readProtected(path.join(sourcePin.registryDirectory,'operator-public.pem'),4096), ]) handoff=await verifyLegacyProbeHandoffIntent(sourcePin,{archive,signedApproval,coldArchive,intent,operatorPublicKeyPem}) } // Use the same protected registry evidence for inspection and publication. const verifier=createProtectedDatabaseSourceBindingVerifier(sourcePin) async function connected(sourceVerifier:typeof verifier,deadlineAt:number){ const publisher=createConnectedPublisher(installation,(s:Parameters[0])=>collectCatalogue(s,installation),sourceVerifier,pinned,reviewedDefinition) const pool=new pg.Pool(options) // A pool-level async error never becomes raw stdout or a retry signal. let asyncFailure=false;pool.on('error',()=>{asyncFailure=true}) let result,primary:unknown,failed=false try{ const journalDirectory=get('journal') if(legacyInspection)result=await publisher.inspectLegacyStorage(pool,{deadlineAt,archiveDirectory,custody:legacyCustody,handoff}) else if(catalogueInspection)result=await publisher.inspectCurrentCatalogue(pool,{deadlineAt}) else if(preflight)result=await publisher.preflightCurrentProfile(pool,{deadlineAt}) else if(args[0]==='reconcile')result=await publisher.reconcilePendingPublication(pool,{journalDirectory,deadlineAt}) else{ const publication={privateKeyFile,expectedHeadSha256:pinned.expectedHeadSha256,journalDirectory,validityMs:pinned.validityMs,deadlineAt} result=upgrade?await publisher.upgradeCurrentProfile(pool,publication):await publisher.publishCurrentProfile(pool,publication) } } catch(error){primary=error;failed=true} try{await pool.end()}catch(error){primary??=error;failed=true} if(legacyInspection&&result?.state==='observed'&&result.source.platformProtectionVerified===true&&!failed&&!asyncFailure){ const {installationId,sourceIdentityId,generation,ordinal,headSha256,bindingSha256}=result.source if(legacyHandoff){assert(result.resolution);return {event:'database-legacy-handoff-inspection',...result.resolution,sourceActivationMatched:true,conversionAllowed:false}} return {...(legacyExport?{archive:result.archive}:{}),...(result.lineageSnapshot?{lineageSnapshot:result.lineageSnapshot}:{}),event:'database-legacy-inspection',outcome:'observed',snapshot:result.snapshot, source:{installationId,sourceIdentityId,generation,ordinal,headSha256,bindingSha256},sourceActivationMatched:true, platformProtectionVerified:true,generationAuthenticated:false,allWriterDrainAuthenticated:false, conversionAllowed:false,readyAuthorized:false,automaticReplay:false} } if(catalogueInspection&&result?.state==='observed'&&result.platformProtectionVerified===true&&!failed&&!asyncFailure){ const {state:_state,...catalogue}=result return {event:'application-writer-source-catalogue-inspection',outcome:'observed',...catalogue,automaticReplay:false,writerAuthorized:false} } if(preflight&&result?.state==='matched'&&result.platformProtectionVerified===true&&!failed&&!asyncFailure)return {event:'application-writer-profile-preflight',outcome:'matched',epoch:result.epoch,headSha256:result.headSha256,notAfter:result.notAfter,sourceMatched:true,rolesMatched:true,catalogueMatched:true,platformProtectionVerified:true,writerAuthorized:false,cleanupUnconfirmed:false,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false} if(result?.outcome==='committed')return {event:'application-writer-profile-publication',outcome:'committed',epoch:result.epoch,headSha256:result.headSha256,notAfter:result.notAfter, cleanupUnconfirmed:result.cleanupUnconfirmed||asyncFailure||failed,journalUnconfirmed:!!result.journalUnconfirmed,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false} if(args[0]==='reconcile'&&result&&!failed&&!asyncFailure&&['idle','confirmed','not-committed'].includes(result.state))return {event:'application-writer-profile-reconciliation',outcome:result.state,headSha256:result.headSha256??null,cleanupUnconfirmed:false,journalUnconfirmed:false,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false} throw primary??Error('Publisher terminal unconfirmed') } const deadlineAt=Date.now()+120000 if(!legacyInspection&&!catalogueInspection&&!activePreflight&&!writes)return connected(verifier,deadlineAt) const {withActiveSource}=await import('./writer-profile/source-activation.mjs') const publisherRole=request.roles.publisher.name const expectedSource={...request.source,databaseOid:Number(request.source.databaseOid),sessionUser:publisherRole,currentUser:publisherRole} const active=()=>withActiveSource({directory:get('activation-directory'),expectedSha256:get('activation-sha256'),sourcePin,expectedSource,tlsSpkiSha256:request.tls.spkiSha256,deadlineAt},verifier, guardedVerifier=>connected(guardedVerifier,deadlineAt)) if(archiveDirectory)return withJournalLease(archiveDirectory,async()=>{ assert.deepEqual(await readdir(archiveDirectory),['publisher-lease.lock'],'Empty protected archive directory required') const keyBytes=await readProtected(get('source-signing-key'),8192) let key try{key=createPrivateKey(keyBytes)}finally{keyBytes.fill(0)} assert(key.asymmetricKeyType==='ed25519'&&sha(createPublicKey(key).export({type:'spki',format:'der'}))===sourcePin.publicKeySpkiSha256,'Source signer differs from deployment pin') const {sourceBindingBytes,sourceBindingCanonical}=await import('../src/db/database-source-binding.js') const {LEGACY_PROBE_ARCHIVE_APPROVAL_DOMAIN,LEGACY_PROBE_CUSTODY_APPROVAL_DOMAIN}=await import('../src/services/server-probe-legacy-archive-approval.js') const result=await active() assert(result.event==='database-legacy-inspection'&&Buffer.isBuffer(result.archive)&&Date.now()