260 lines
22 KiB
JavaScript
260 lines
22 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import {randomBytes,randomUUID,sign,X509Certificate} from 'node:crypto'
|
|
import {mkdir,readFile,writeFile} from 'node:fs/promises'
|
|
import {join} from 'node:path'
|
|
import pg from 'pg'
|
|
|
|
export async function verifyOwnedLegacyExecution({main,live,options,directory,archiveDirectory,coldState,leafBytes,originalPin,fullArchive,signedApproval,
|
|
adopt,release,tail,sourcePrivateKey,coldPrivateKey,coldPublicKey,proof,coldApprovalSha256}){
|
|
assert.equal(process.env.MMAPP_OWN_PROBE_LEGACY_0037,'true')
|
|
const [{sourceBindingBytes,sourceBindingCanonical,sourceBindingSha256,readDatabaseSourceBindingRegistry},{readReviewedLegacyProbe0037},
|
|
{LEGACY_HANDOFF_EXECUTION_DOMAIN,LEGACY_HANDOFF_RELEASE_DOMAIN},{captureLegacyHandoffSchema},{LEGACY_PROBE_RELATIONS},{acquireDatabaseSchemaControl},{observation,exactHistory},
|
|
{MIGRATION_MANIFEST,migrationManifestDigest},{DATABASE_RESTORE_QUARANTINE_DDL},{createBootstrapMaterial}]=await Promise.all([
|
|
import('../src/db/database-source-binding.ts'),import('../src/db/legacy-probe-0037-body.ts'),import('./writer-profile/legacy-handoff-execution.mts'),
|
|
import('../src/services/server-probe-legacy-handoff-inspection.ts'),import('../src/services/server-probe-legacy-source-inventory.ts'),
|
|
import('../src/db/database-schema-control.ts'),import('../src/db/controlled-migration-history.ts'),import('../src/db/migration-manifest.ts'),
|
|
import('../src/db/database-restore-quarantine.ts'),import('./database-writer-bootstrap-operator.mjs'),
|
|
])
|
|
const sha=sourceBindingSha256,store=async(path,data)=>{await writeFile(path,data,{flag:'wx',mode:0o600});return path}
|
|
const publisher=options.user,operator='owned_commit_operator',control='owned_commit_control'
|
|
const appPassword=tail?.password??randomBytes(24).toString('hex'),controlPassword=randomBytes(24).toString('hex')
|
|
await live.query(DATABASE_RESTORE_QUARANTINE_DDL)
|
|
if(tail)assert.equal(tail.user,operator)
|
|
else await live.query(`CREATE ROLE ${operator} LOGIN PASSWORD '${appPassword}'; GRANT ${publisher} TO ${operator}; ALTER SCHEMA public OWNER TO ${operator}`)
|
|
await live.query(`CREATE ROLE ${control} LOGIN PASSWORD '${controlPassword}';
|
|
CREATE ROLE owned_commit_runtime NOLOGIN; CREATE ROLE owned_commit_capture NOLOGIN;
|
|
GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO ${control},${operator}; GRANT pg_read_all_stats TO ${control};
|
|
GRANT USAGE ON SCHEMA mmapp_control TO ${control},${operator}; GRANT SELECT, UPDATE ON mmapp_control.database_schema_state,mmapp_control.database_restore_quarantine TO ${control},${operator};
|
|
GRANT SELECT, INSERT, UPDATE ON mmapp_control.database_schema_intents TO ${control},${operator}`)
|
|
let runTail
|
|
if(tail){
|
|
const [{pool},{executeControlledSqlMigrations},{LEGACY_CONTROL_REFERENCE_DOMAIN,readControlledSchemaReference},{verifyControlledSchemaCurrentState}]=await Promise.all([
|
|
import('../src/db/index.ts'),import('../src/db/controlled-migrations.ts'),import('../src/db/controlled-schema-reference-core.ts'),
|
|
import('../src/db/controlled-schema-verification.ts'),
|
|
])
|
|
runTail=async(quarantined,handoff)=>{
|
|
const files=[],fileHashes=new Map(MIGRATION_MANIFEST.map(pin=>[pin.sha256,pin.file]))
|
|
const originalConnect=pool.connect
|
|
pool.connect=async()=>{
|
|
const owned=await originalConnect.call(pool),query=owned.query,release=owned.release
|
|
owned.query=function(text,...args){
|
|
const file=typeof text==='string'&&fileHashes.get(sha(Buffer.from(text)))
|
|
if(file)files.push(file)
|
|
return query.call(this,text,...args)
|
|
}
|
|
owned.release=function(...args){owned.query=query;owned.release=release;return release.apply(this,args)}
|
|
return owned
|
|
}
|
|
try{
|
|
if(quarantined){
|
|
await assert.rejects(executeControlledSqlMigrations(),error=>error.cause?.message==='Authenticated legacy migration release required')
|
|
assert.deepEqual(files,[])
|
|
return
|
|
}
|
|
const result=await executeControlledSqlMigrations()
|
|
assert.equal(result.completedFiles,MIGRATION_MANIFEST.length);assert.equal(result.ready,false)
|
|
assert.deepEqual(files,MIGRATION_MANIFEST.slice(37).map(pin=>pin.file))
|
|
}finally{pool.connect=originalConnect}
|
|
const referenceRoles={publisher:request.roles.publisher,operator:request.roles.operator,control:request.roles.control}
|
|
const approvalBody={format:'legacy-control-reference-approval-v1',manifestSha256,sourceHeadSha256:source.headSha256,
|
|
sourceTlsSpkiSha256:tls.spkiSha256,...referenceRoles,expiresAt:Date.now()+90000}
|
|
const referenceArgs=async(body,filename)=>{
|
|
const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_CONTROL_REFERENCE_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')})
|
|
const flags=['--bootstrap','--bootstrap-sha256','--publisher-transport','--publisher-transport-sha256','--operator-transport','--operator-transport-sha256',
|
|
'--ca','--source-registry','--source-spki-sha256','--activation-directory','--activation-sha256','--cold-public-key','--cold-spki-sha256']
|
|
return ['legacy-control-reference',...flags.flatMap(flag=>[flag,args[args.indexOf(flag)+1]]),
|
|
'--approval',await store(join(directory,filename),bytes),'--approval-sha256',sha(bytes)]
|
|
}
|
|
await assert.rejects(main(await referenceArgs({...approvalBody,control:referenceRoles.operator},'wrong-control-reference.json')),/independent split-control approval/)
|
|
const approved=await referenceArgs(approvalBody,'control-reference.json')
|
|
const reference=await main(approved),current=await verifyControlledSchemaCurrentState()
|
|
assert.equal(reference.splitControlApprovalSha256,approved.at(-1));assert.equal(reference.referenceDatabaseDropped,true)
|
|
assert.equal((await readControlledSchemaReference()).sha256,current.schemaSha256)
|
|
assert.equal(current.schemaSha256,reference.logicalSchemaSha256);assert.equal(current.referenceStatus,'matched');assert.equal(current.ready,false)
|
|
assert.equal(current.currentPristineDataInvariants,false)
|
|
await live.query('GRANT USAGE ON SCHEMA mmapp_control TO owned_commit_runtime')
|
|
try{
|
|
const extra=await verifyControlledSchemaCurrentState()
|
|
assert.equal(extra.referenceStatus,'different');assert.equal(extra.ready,false);assert.equal(extra.dataFacts.length,0)
|
|
}finally{await live.query('REVOKE USAGE ON SCHEMA mmapp_control FROM owned_commit_runtime')}
|
|
const [{LEGACY_SOURCE58_PREFLIGHT_DOMAIN},{RESTORE_WRITER_PROFILE_DEFINITION_SHA256}]=await Promise.all([
|
|
import('../src/db/legacy-source58-transition.ts'),import('../src/db/database-restore-quarantine-profile.ts'),
|
|
])
|
|
const targetCatalogueSha256=sha(Buffer.from('owned signed intended Source58 target; installation outside this preflight'))
|
|
const target={format:'legacy-source58-preflight-approval-v1',manifestSha256,sourceHeadSha256:source.headSha256,
|
|
sourceTlsSpkiSha256:tls.spkiSha256,currentSchemaSha256:reference.logicalSchemaSha256,...handoff,
|
|
targetDefinitionSha256:RESTORE_WRITER_PROFILE_DEFINITION_SHA256,targetCatalogueSha256,roles:request.roles,expiresAt:Date.now()+90000}
|
|
const preflightArgs=async(body,name)=>{
|
|
const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_SOURCE58_PREFLIGHT_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')})
|
|
const flags=approved.slice(1,-4),operatorAt=flags.indexOf('--operator-transport')
|
|
flags.splice(operatorAt,4)
|
|
return ['legacy-source58-preflight',...flags,'--approval',await store(join(directory,name),bytes),'--approval-sha256',sha(bytes)]
|
|
}
|
|
await assert.rejects(main(await preflightArgs({...target,releaseApprovalSha256:'0'.repeat(64)},'wrong-source58-target.json')),/exact authenticated release/)
|
|
const observed=await main(await preflightArgs(target,'source58-target.json'))
|
|
assert.equal(observed.authenticatedFiles,MIGRATION_MANIFEST.length);assert.equal(observed.transitionAuthorized,false);assert.equal(observed.readyAuthorized,false)
|
|
assert.equal(observed.approvedTargetCatalogueSha256,targetCatalogueSha256)
|
|
const expectedBlockers=['CONTROL_NAMESPACE_OWNER','QUARANTINE_OWNER','WRITER_REGISTRY_MISSING','REVIEWED_MARKER_FENCE_MISSING',
|
|
'ROLE_PROFILE_OPERATOR','ROLE_PROFILE_PUBLISHER','ROLE_PROFILE_RUNTIME','ROLE_PROFILE_CAPTURE']
|
|
assert.deepEqual(observed.blockers,expectedBlockers)
|
|
return {manifestSha256,logicalSchemaSha256:current.schemaSha256,referenceLogicalSchemaSha256:reference.logicalSchemaSha256,
|
|
referenceStatus:current.referenceStatus,splitControlApprovalSha256:reference.splitControlApprovalSha256,exactSplitControlCatalogueMatched:true,
|
|
invalidRoleRefused:true,excessNamespaceAclRefused:true,
|
|
referenceDatabaseDropped:reference.referenceDatabaseDropped,
|
|
files,legacySource58PredecessorAttested:true,wrongReleasePinRefused:true,source58Blockers:observed.blockers,
|
|
source58TransitionAuthorized:false,readyAuthorized:current.ready,historicalDataEquivalent:current.historicalDataEquivalent}
|
|
}
|
|
}
|
|
const manifestSha256=migrationManifestDigest(),controller=await acquireDatabaseSchemaControl(live)
|
|
try{
|
|
for(const migration of MIGRATION_MANIFEST.slice(0,36)){
|
|
const id=randomUUID(),begun=await controller.transition({type:'begin',id,kind:'migration',manifestSha256,artifactSha256:migration.sha256})
|
|
await controller.transition({type:'terminal',id,outcome:'observed-success',observationSha256:await observation(begun.state.intent,migration)})
|
|
}
|
|
}finally{await controller.close()}
|
|
const {body,pin}=await readReviewedLegacyProbe0037(),preview=new pg.Client({...options,user:operator,password:appPassword})
|
|
await preview.connect()
|
|
let preSchemaSha256,postSchemaSha256
|
|
try{
|
|
await preview.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
|
|
preSchemaSha256=await captureLegacyHandoffSchema(preview,Date.now()+30000);await preview.query('ROLLBACK')
|
|
await preview.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE')
|
|
await preview.query(`TRUNCATE TABLE ${LEGACY_PROBE_RELATIONS.map(name=>`ONLY public.${name}`).join(', ')} CONTINUE IDENTITY RESTRICT`)
|
|
await preview.query(body);await preview.query('SET TRANSACTION READ ONLY')
|
|
postSchemaSha256=await captureLegacyHandoffSchema(preview,Date.now()+30000)
|
|
}finally{try{await preview.query('ROLLBACK')}finally{await preview.end()}}
|
|
assert.notEqual(preSchemaSha256,postSchemaSha256)
|
|
const source=await readDatabaseSourceBindingRegistry(originalPin),host='localhost',tls={serverName:host,caSha256:sha(leafBytes),
|
|
spkiSha256:sha(new X509Certificate(leafBytes).publicKey.export({type:'spki',format:'der'}))}
|
|
const names={publisher,operator,control,runtime:'owned_commit_runtime',capture:'owned_commit_capture'}
|
|
const {rows:rows}=await live.query('SELECT rolname AS name,oid::text AS "signedOid" FROM pg_catalog.pg_roles WHERE rolname=ANY($1)',[Object.values(names)])
|
|
const request={format:'application-writer-bootstrap-request-v1',installationId:originalPin.installationId,sourceHeadSha256:originalPin.currentHeadSha256,tls,
|
|
roles:Object.fromEntries(Object.entries(names).map(([scope,name])=>[scope,rows.find(role=>role.name===name)])),source:{systemIdentifier:source.body.source.systemIdentifier,
|
|
databaseOid:String(source.body.source.databaseOid),databaseName:source.body.source.databaseName,serverVersionNum:source.body.source.serverVersionNum,inRecovery:false}}
|
|
const bootstrap=sourceBindingBytes(createBootstrapMaterial(request,sha(sourceBindingBytes(request))).bootstrap)
|
|
const activeDirectory=join(directory,'owned-execute-activation');await mkdir(activeDirectory,{mode:0o700})
|
|
const activation=sourceBindingBytes({format:'database-source-activation-v1',activationDirectory:activeDirectory,installationId:originalPin.installationId,
|
|
sourceIdentityId:source.body.sourceIdentityId,status:'active',publicKeySpkiSha256:originalPin.publicKeySpkiSha256,
|
|
generations:[{generation:source.body.generation,headSha256:source.headSha256,bindingSha256:source.head.bindingSha256,tlsSpkiSha256:tls.spkiSha256}]})
|
|
await store(join(activeDirectory,'source-activation.json'),activation)
|
|
const operationId=randomUUID(),approvalBody={format:'legacy-probe-0037-execution-approval-v1',decision:'execute-and-commit',operationId,
|
|
sourceHeadSha256:originalPin.currentHeadSha256,sourceTlsSpkiSha256:tls.spkiSha256,custodySha256:sha(signedApproval),coldArchiveSha256:sha(fullArchive),
|
|
coldProofSha256:sha(proof),coldApprovalSha256,preSchemaSha256,postSchemaSha256,manifestSha256,migrationSha256:pin.sha256,protectedRuntimePaused:true,expiresAt:Date.now()+90000}
|
|
const approved=sourceBindingBytes({body:approvalBody,signature:sign(null,Buffer.from(LEGACY_HANDOFF_EXECUTION_DOMAIN+sourceBindingCanonical(approvalBody)),coldPrivateKey).toString('base64url')})
|
|
await store(join(archiveDirectory,'legacy-probe-cold-proof.json'),proof)
|
|
const shared=['--bootstrap',await store(join(directory,'execute-bootstrap.json'),bootstrap),'--bootstrap-sha256',sha(bootstrap),
|
|
'--ca',await store(join(directory,'execute-ca.pem'),leafBytes),'--source-registry',originalPin.registryDirectory,'--source-spki-sha256',originalPin.publicKeySpkiSha256,
|
|
'--activation-directory',activeDirectory,'--activation-sha256',sha(activation),'--archive-directory',archiveDirectory]
|
|
const args=['legacy-handoff-execute',...shared,'--legacy-key-directory',coldState,'--source-signing-key',await store(join(directory,'execute-source-key.pem'),sourcePrivateKey.export({type:'pkcs8',format:'pem'})),
|
|
'--approval',await store(join(directory,'execute-approval.json'),approved),'--approval-sha256',sha(approved),'--cold-public-key',await store(join(directory,'execute-cold-pub.pem'),coldPublicKey.export({type:'spki',format:'pem'})),
|
|
'--cold-spki-sha256',sha(coldPublicKey.export({type:'spki',format:'der'}))]
|
|
let publisherTransport,publisherSha
|
|
for(const [scope,user,password] of [['publisher',publisher,options.password],['operator',operator,appPassword],['control',control,controlPassword]]){
|
|
const transport=sourceBindingBytes({host,port:options.port,database:options.database,user,password})
|
|
const file=await store(join(directory,'execute-'+scope+'.json'),transport);args.push('--'+scope+'-transport',file,'--'+scope+'-transport-sha256',sha(transport))
|
|
if(scope==='publisher'){publisherTransport=file;publisherSha=sha(transport)}
|
|
}
|
|
const {rows:[credential]}=await live.query('SELECT id,digest FROM public.mcp_credentials LIMIT 1')
|
|
await live.query('UPDATE public.mcp_credentials SET digest=$2 WHERE id=$1',[credential.id,randomUUID()])
|
|
try{await assert.rejects(main(args),/Original credentials differ/)}finally{await live.query('UPDATE public.mcp_credentials SET digest=$2 WHERE id=$1',[credential.id,credential.digest])}
|
|
assert.equal((await live.query('SELECT operation_id FROM mmapp_control.database_restore_quarantine')).rows[0].operation_id,null)
|
|
const connect=pg.Pool.prototype.connect
|
|
let applicationCommits=0
|
|
pg.Pool.prototype.connect=function(...args){
|
|
const connection=connect.apply(this,args)
|
|
if(args.length||this.options.application_name!=='mmapp-legacy-handoff-owner')return connection
|
|
return connection.then(client=>{
|
|
const query=client.query
|
|
client.query=function(text,...params){
|
|
const result=query.call(this,text,...params)
|
|
if(text!=='COMMIT')return result
|
|
return result.then(()=>{applicationCommits++;throw Error('owned application COMMIT ACK lost')})
|
|
}
|
|
return client
|
|
})
|
|
}
|
|
try{await assert.rejects(main(args),{code:'LEGACY_HANDOFF_EXECUTION_UNKNOWN'})}finally{pg.Pool.prototype.connect=connect}
|
|
assert.equal(applicationCommits,1)
|
|
const intent=await readFile(join(archiveDirectory,'legacy-probe-handoff-intent.json'))
|
|
const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-application-unknown.json'),'utf8'))
|
|
assert.equal(unknown.operationId,operationId);assert.equal(unknown.automaticReplay,false)
|
|
const inspectArgs=['legacy-handoff-inspect',...shared,'--transport',publisherTransport,'--transport-sha256',publisherSha,'--handoff-intent-sha256',sha(intent)]
|
|
const inspected=await main(inspectArgs)
|
|
assert.equal(inspected.outcome,'committed');assert.equal(inspected.operationId,operationId);assert.equal(inspected.quarantineActive,true)
|
|
assert.equal((await live.query('SELECT operation_id FROM mmapp_control.database_restore_quarantine')).rows[0].operation_id,operationId)
|
|
await assert.rejects(main(args),{code:'DATABASE_RESTORE_QUARANTINE_UNAVAILABLE'})
|
|
assert.equal(applicationCommits,1)
|
|
if(adopt){
|
|
assert.equal(inspected.adoptionRecorded,false)
|
|
const adoptArgs=[...args];adoptArgs[0]='legacy-handoff-adopt'
|
|
adoptArgs.splice(adoptArgs.indexOf('--source-signing-key'),2,'--handoff-intent-sha256',sha(intent))
|
|
let action=adoptArgs,unknownCode='LEGACY_HANDOFF_ADOPTION_UNKNOWN',releaseApprovalSha256
|
|
if(release){
|
|
const adopted=await main(adoptArgs)
|
|
assert.equal(adopted.quarantineActive,true)
|
|
if(runTail)await runTail(true)
|
|
const signedRelease=async(adoptionSha256,name)=>{
|
|
const body={format:'legacy-probe-0037-release-approval-v1',decision:'release-migration-quarantine',operationId,intentSha256:sha(intent),adoptionSha256,
|
|
sourceHeadSha256:originalPin.currentHeadSha256,sourceTlsSpkiSha256:tls.spkiSha256,coldArchiveSha256:sha(fullArchive),
|
|
coldProofSha256:sha(proof),postSchemaSha256,manifestSha256,migrationSha256:pin.sha256,protectedRuntimePaused:true,expiresAt:Date.now()+90000}
|
|
const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_HANDOFF_RELEASE_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')})
|
|
return ['legacy-handoff-release',...adoptArgs.slice(1),'--release-approval',await store(join(directory,name),bytes),'--release-approval-sha256',sha(bytes)]
|
|
}
|
|
await assert.rejects(main(await signedRelease('0'.repeat(64),'wrong-release.json')),/Exact committed legacy handoff phase/)
|
|
assert.equal((await main(inspectArgs)).quarantineActive,true)
|
|
action=await signedRelease(adopted.observationSha256,'release.json')
|
|
releaseApprovalSha256=action.at(-1);unknownCode='LEGACY_HANDOFF_RELEASE_UNKNOWN'
|
|
}
|
|
let controlCommits=0
|
|
pg.Pool.prototype.connect=function(...parameters){
|
|
const connection=connect.apply(this,parameters)
|
|
if(parameters.length||this.options.application_name!=='mmapp-writer-registry-enroll')return connection
|
|
return connection.then(client=>{
|
|
const query=client.query
|
|
client.query=function(text,...params){
|
|
const result=query.call(this,text,...params)
|
|
if(text!=='COMMIT')return result
|
|
return result.then(ack=>{if(++controlCommits===2)throw Error('owned adoption COMMIT ACK lost');return ack})
|
|
}
|
|
return client
|
|
})
|
|
}
|
|
try{await assert.rejects(main(action),{code:unknownCode})}finally{pg.Pool.prototype.connect=connect}
|
|
assert.equal(controlCommits,2)
|
|
const readback=await main(inspectArgs)
|
|
assert.equal(readback.adoptionRecorded,true);assert.equal(readback.outcome,'committed');assert.equal(readback.readyAuthorized,false)
|
|
const {rows:[gate]}=await live.query('SELECT q.operation_id::text AS active,s.state FROM mmapp_control.database_restore_quarantine q CROSS JOIN mmapp_control.database_schema_state s WHERE q.id=1 AND s.id=1')
|
|
const {rows:history}=await live.query('SELECT id::text,intent,terminal FROM mmapp_control.database_schema_intents')
|
|
assert.equal(gate.active,release?null:operationId);assert.equal(gate.state.intent,null)
|
|
assert.equal(gate.state.terminal.intent.artifactSha256,sha(intent))
|
|
assert.equal(await exactHistory(history,gate.state,manifestSha256,true),37)
|
|
if(release){
|
|
assert.equal(readback.releaseRecorded,true);assert.equal(readback.quarantineActive,false);assert.equal(readback.releaseApprovalSha256,releaseApprovalSha256)
|
|
assert.equal(gate.state.terminal.legacyRelease.approvalSha256,releaseApprovalSha256)
|
|
const {rows:[head]}=await live.query('SELECT journal_prefix_bytes,journal_prefix_sha256 FROM mmapp_control.database_restore_quarantine')
|
|
assert.deepEqual(head,{journal_prefix_bytes:null,journal_prefix_sha256:null})
|
|
const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-release-unknown.json'),'utf8'))
|
|
assert.deepEqual(unknown,{format:'legacy-probe-0037-release-unknown-v1',operationId,intentSha256:sha(intent),automaticReplay:false})
|
|
await assert.rejects(main(action),/Legacy release attempt requires inspection/)
|
|
if(runTail){
|
|
const markers=()=>live.query('SELECT id,xmin::text AS xmin,applied_at::text FROM public.schema_migrations ORDER BY id').then(result=>result.rows)
|
|
const ledger=()=>live.query('SELECT id::text,xmin::text AS xmin,intent,terminal FROM mmapp_control.database_schema_intents ORDER BY id').then(result=>result.rows)
|
|
const beforeMarkers=await markers(),beforeLedger=await ledger()
|
|
const result=await runTail(false,{operationId,intentSha256:sha(intent),releaseApprovalSha256})
|
|
assert.deepEqual((await markers()).slice(0,37),beforeMarkers)
|
|
const afterLedger=new Map((await ledger()).map(row=>[row.id,row]))
|
|
assert(beforeLedger.every(row=>JSON.stringify(row)===JSON.stringify(afterLedger.get(row.id))))
|
|
assert.equal((await main(inspectArgs)).releaseRecorded,true)
|
|
return {controlledLegacyTailCompleted:true,quarantinedDispatchRefused:true,originalReceiptsAndMarkersPreserved:true,...result}
|
|
}
|
|
return {legacyHandoffReleased:true,wrongAdoptionRefused:true,releaseAckLossObserved:true,exactAuthenticatedPrefix:37,
|
|
replayRefused:true,restoreJournalUnchanged:true,readyAuthorized:false}
|
|
}
|
|
const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-adoption-unknown.json'),'utf8'))
|
|
assert.deepEqual(unknown,{format:'legacy-probe-0037-adoption-unknown-v1',operationId,intentSha256:sha(intent),automaticReplay:false})
|
|
await assert.rejects(main(adoptArgs),/Legacy adoption attempt requires inspection/)
|
|
return {legacyHandoffAdopted:true,adoptionAckLossObserved:true,exactAuthenticatedPrefix:37,replayRefused:true,quarantineCleared:false,readyAuthorized:false}
|
|
}
|
|
return {legacyHandoffExecuted:true,credentialDriftRefused:true,applicationAckLossObserved:true,committedReconciled:true,quarantineCleared:false,readyAuthorized:false}
|
|
}
|