Files
dxdesigner-part-replacement/tools/verify_dsh_incident_restart.mjs
T
阿白叔 cffef93b37
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m35s
Core regression / JavaScript syntax (push) Successful in 6s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 3m54s
Core regression / JavaScript syntax (pull_request) Successful in 4s
fix: persist incident isolation and atomically publish netlist evidence
2026-11-13 17:28:05 +08:00

161 lines
12 KiB
JavaScript

/** Real Harness, two processes: automatic diagnosis must stay isolated after restart. */
import assert from 'node:assert/strict';
import {mkdir,mkdtemp,writeFile,readFile,unlink,symlink} from 'node:fs/promises';
import path from 'node:path';
import {createHash} from 'node:crypto';
import {createRequire} from 'node:module';
import {fileURLToPath,pathToFileURL} from 'node:url';
import {spawnSync} from 'node:child_process';
import {bootRuntime} from '../integration/dsh/start.mjs';
const require=createRequire(new URL('../integration/dsh/start.mjs',import.meta.url));
const phase=process.argv[2],fixture=process.argv[3];
if(!phase){
const output=path.resolve('build/dsh-incident-restart-verification');await mkdir(output,{recursive:true});
const root=await mkdtemp(path.join(output,'run-'));
const env={...process.env,DX_DSH_HOME:path.join(root,'home'),DX_DSH_CONTEXT_FILE:path.join(root,'context.json'),
DX_DSH_WORKSPACE:path.join(root,'workspace')};
for(const key of ['DSH_API_KEY','DSH_API_BASE','DSH_MODEL','DX_DSH_MODELS'])delete env[key];
await mkdir(env.DX_DSH_WORKSPACE,{recursive:true});
await writeFile(env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'original-current',revision:'original',status:'observe'}));
for(const stage of ['create','restart']){
const run=spawnSync(process.execPath,[fileURLToPath(import.meta.url),stage,root],{env,encoding:'utf8',timeout:120000});
await writeFile(path.join(root,stage+'.stdout.txt'),run.stdout??'');
await writeFile(path.join(root,stage+'.stderr.txt'),run.stderr??'');
assert.equal(run.error,undefined,stage+': '+run.error);
assert.equal(run.status,0,stage+': '+run.stderr);
}
const report=JSON.parse(await readFile(path.join(root,'report.json'),'utf8'));
console.log(JSON.stringify({...report,evidenceRoot:root}));
}else{
const {ctx,shutdown}=await bootRuntime({announce:false});
try{
if(phase==='create'){
const {LlmAdapter}=await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-llm')).href);
class Fixture extends LlmAdapter{
providerInfo(provider){return {id:provider,name:'Owned local fixture'};}
async listModels(provider){return [{provider,id:'fixture',name:'Fixture'}];}
async *stream(){
yield {type:'block-start',index:0,blockType:'text'};
yield {type:'block-end',index:0,block:{type:'text',text:'Owned diagnosis fixture. {"action":"none"}'}};
yield {type:'finish',reason:{kind:'stop'}};
}
}
ctx.llm.registerAdapter(['incident-restart-fixture'],new Fixture());
await ctx.agentDefaultModel.saveSelection({provider:'incident-restart-fixture',model:'fixture'});
let sessionId,completed=false;
const write=process.stdout.write.bind(process.stdout);
process.stdout.write=(chunk,...args)=>{
if(String(chunk).startsWith('DX_DSH_DIAGNOSIS ')){
const row=JSON.parse(String(chunk).slice('DX_DSH_DIAGNOSIS '.length));
if(row.status==='started')sessionId=row.session_id;
if(row.status==='completed')completed=true;
}
return write(chunk,...args);
};
ctx.emit('dx/diagnose-request',{request_id:'restart-proof',incident_id:'b'.repeat(24),phase:'diagnose',
snapshot:{task_id:'incident-original',task_name:'Restart fixture',status:'failed',issue_code:'owned_fixture'},
evidence:'Owned fixture only. No CAD or remote model.'});
const deadline=Date.now()+30000;
while(!completed&&Date.now()<deadline)await new Promise(resolve=>setTimeout(resolve,20));
assert.ok(completed&&sessionId,'automatic fixture did not complete');
const agent=ctx.agents.get(sessionId);
await agent.whenIdle();
// Renaming cannot remove the reserved immutable session identity.
await ctx.sessionController.rename({sessionId,title:'Renamed historical conversation'});
await ctx.parallel('session/flush',agent.session);
const workspace=await ctx.workspaceRegistry.create(process.env.DX_DSH_WORKSPACE,'Legacy fixture');
const {sessionId:legacyId}=await ctx.sessionController.create({workspaceId:workspace.id,agentPreset:'dx-task'});
await ctx.sessionController.rename({sessionId:legacyId,title:'Legacy program-owned diagnosis'});
await ctx.parallel('session/flush',ctx.agents.get(legacyId).session);
const legacyDirectory=path.join(process.env.DX_DSH_HOME,'..','incidents','c'.repeat(24));
await mkdir(legacyDirectory,{recursive:true});
await writeFile(path.join(legacyDirectory,'incident.json'),JSON.stringify({incident_id:'c'.repeat(24),task_id:'legacy-original',
analyses:[{phase:'diagnose',session_id:legacyId,reply:'Recorded by coordinator'}]}));
await writeFile(path.join(legacyDirectory,'snapshot.json'),JSON.stringify({task_id:'legacy-original',status:'failed'}));
const {sessionId:conflictingId}=await ctx.sessionController.create({workspaceId:workspace.id,agentPreset:'dx-task'});
await ctx.sessionController.rename({sessionId:conflictingId,title:'Conflicting program ledger fixture'});
await ctx.parallel('session/flush',ctx.agents.get(conflictingId).session);
for(const id of ['d','e']){
const directory=path.join(legacyDirectory,'..',id.repeat(24));await mkdir(directory,{recursive:true});
await writeFile(path.join(directory,'incident.json'),JSON.stringify({incident_id:id.repeat(24),
analyses:[{phase:'diagnose',session_id:conflictingId,reply:'Conflicting recorded identity'}]}));
await writeFile(path.join(directory,'snapshot.json'),JSON.stringify({task_id:'must-not-select-ambiguous-snapshot'}));
}
await mkdir(path.join(legacyDirectory,'..','f'.repeat(24)),{recursive:true});
const corruptDirectory=path.join(legacyDirectory,'..','0'.repeat(24));await mkdir(corruptDirectory,{recursive:true});
await writeFile(path.join(corruptDirectory,'incident.json'),'broken incident record');
const linkDirectory=path.join(legacyDirectory,'..','1'.repeat(24));await mkdir(linkDirectory,{recursive:true});
let symlinkCreated=false;
try{await symlink(path.join(legacyDirectory,'incident.json'),path.join(linkDirectory,'incident.json'));symlinkCreated=true;}
catch(error){if(!['EPERM','ENOTSUP','EACCES'].includes(error.code))throw error;}
await writeFile(path.join(fixture,'identity.json'),JSON.stringify({sessionId,legacyId,conflictingId,symlinkCreated}));
}else{
await writeFile(process.env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'different-current',revision:'later',status:'ready'}));
const {sessionId,legacyId,conflictingId,symlinkCreated}=JSON.parse(await readFile(path.join(fixture,'identity.json'),'utf8'));
const resumed=await ctx.sessionController.resolveAgent(sessionId);
assert.ok(resumed.agent,JSON.stringify(resumed.error));
const agent=resumed.agent;
const call=(owner,name,args={})=>ctx.tools.execute({name,arguments:args,callId:crypto.randomUUID(),agent:owner,signal:AbortSignal.timeout(5000)});
const snapshot=await call(agent,'dx_task_snapshot');
assert.equal(snapshot.isError,false,JSON.stringify(snapshot));
assert.equal(snapshot.value.task_id,'incident-original','historical diagnosis must not read the current task');
assert.equal(snapshot.value.revision,'b'.repeat(24));
assert.match(sessionId,/^session-dx-incident-/,'new sessions need a durable reserved identity');
const {defineTool}=await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-tools')).href);
let extensionCalls=0;
ctx.tools.register(defineTool({name:'restart_extension_mutation',description:'Owned no-op extension probe',parameters:{},
output:{schema:{type:'object',additionalProperties:true},render:()=>[]},execute:async()=>{extensionCalls++;return {ok:true};}}));
const workspace=await ctx.workspaceRegistry.create(process.env.DX_DSH_WORKSPACE,'Ordinary fixture');
const {sessionId:ordinaryId}=await ctx.sessionController.create({workspaceId:workspace.id,agentPreset:'dx-task'});
const ordinary=ctx.agents.get(ordinaryId);
// User-supplied title text must not turn an ordinary official session into a diagnosis.
await ctx.sessionController.rename({sessionId:ordinaryId,title:'DSH自动诊断 · User supplied title'});
const shell=ctx.tools.schemas(ordinary).find(tool=>/^(bash|pwsh|powershell|shell)$/.test(tool.name));
assert.ok(shell,'ordinary official preset lost its shell capability');
const probes=[['restart_extension_mutation',{}],['write',{file_path:path.join(fixture,'forbidden.txt'),content:'forbidden'}],
['edit',{file_path:path.join(fixture,'forbidden.txt'),old_string:'a',new_string:'b'}],
[shell.name,{command:'echo forbidden',description:'Owned denial probe'}],['dx_task_create',{name:'must be denied'}],
['dx_task_manage',{action:'pause',task_id:'different-current'}],['dx_task_execute',{}]];
for(const [name,args] of probes){
const result=await call(agent,name,args);
assert.equal(result.isError,true,name+' admitted after restart');
assert.match(JSON.stringify(result),/Automatic incident sessions/,name+' did not reach the session guard');
}
assert.equal(extensionCalls,0);
assert.equal((await call(ordinary,'restart_extension_mutation')).isError,false,'ordinary extension was restricted');
assert.equal(extensionCalls,1);
const ordinaryWrite=await call(ordinary,'write',{file_path:path.join(process.env.DX_DSH_WORKSPACE,'ordinary.txt'),content:'ordinary allowed'});
assert.equal(ordinaryWrite.isError,false,JSON.stringify(ordinaryWrite));
const storage=path.join(process.env.DX_DSH_HOME,'incident-snapshots',createHash('sha256').update(sessionId).digest('hex')+'.json');
await unlink(storage);
const missing=await call(agent,'dx_task_snapshot');
assert.equal(missing.isError,true,'missing diagnosis evidence must fail closed');
assert.doesNotMatch(JSON.stringify(missing),/different-current/);
assert.equal((await call(agent,'restart_extension_mutation')).isError,true,'snapshot loss removed classification');
await writeFile(storage,'broken snapshot');
assert.equal((await call(agent,'dx_task_snapshot')).isError,true,'corrupt evidence must fail closed');
const legacy=(await ctx.sessionController.resolveAgent(legacyId)).agent;
assert.ok(legacy,'historical ledger session did not resume');
const legacySnapshot=await call(legacy,'dx_task_snapshot');
assert.equal(legacySnapshot.isError,false,JSON.stringify(legacySnapshot));
assert.equal(legacySnapshot.value.task_id,'legacy-original');
assert.equal(legacySnapshot.value.revision,'c'.repeat(24));
for(const [name,args] of probes)assert.equal((await call(legacy,name,args)).isError,true,'legacy diagnosis admitted '+name);
await unlink(path.join(process.env.DX_DSH_HOME,'..','incidents','c'.repeat(24),'snapshot.json'));
assert.equal((await call(legacy,'dx_task_snapshot')).isError,true,'missing legacy snapshot fell back to current task');
assert.equal((await call(legacy,'restart_extension_mutation')).isError,true);
const conflicted=(await ctx.sessionController.resolveAgent(conflictingId)).agent;
assert.ok(conflicted);
assert.equal((await call(conflicted,'dx_task_snapshot')).isError,true,'conflicting ledgers must not select a snapshot');
assert.equal((await call(conflicted,'restart_extension_mutation')).isError,true,'conflict removed automatic classification');
const report={status:'passed',realHarness:true,separateProcesses:true,remoteModel:false,realCad:false,
restoredIncidentSnapshot:true,missingSnapshotDenied:true,corruptSnapshotDenied:true,
restartMutationDenied:true,newExtensionDenied:true,ordinaryOfficialToolsPreserved:true,userTitleDoesNotClassify:true,
legacyLedgerSessionRestored:true,missingLegacySnapshotDenied:true,conflictingLegacySessionDenied:true,
corruptAndMissingLegacyRecordsDoNotBlockOrdinary:true,symlinkLegacyRecordFixture:symlinkCreated};
await writeFile(path.join(fixture,'report.json'),JSON.stringify(report,null,2));
}
}finally{await shutdown.shutdown(0);}
}