Files
dxdesigner-part-replacement/tools/verify_dsh_diagnosis_cancel.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

160 lines
9.7 KiB
JavaScript

/** Exercise production diagnosis orchestration with controlled session boundaries. */
import assert from 'node:assert/strict';
import {readFile} from 'node:fs/promises';
import vm from 'node:vm';
import path from 'node:path';
import {randomUUID,createHash} from 'node:crypto';
const deferred=()=>{let resolve;const promise=new Promise(yes=>{resolve=yes;});return {promise,resolve};};
const tick=()=>new Promise(resolve=>setImmediate(resolve));
const events=[],handlers=new Map(),routes=new Map(),sessions=new Map(),prompts=[],cancelled=[],selected=[];
let nextCreate=null,nextPrompt=null,latestTimeout,now=1000000,publicationFailure=null;
const publicationCleanup=[];
const timeouts=[];
const context={task_id:'',revision:'current'};
const ctx={on:(name,fn)=>handlers.set(name,fn),effect:()=>{},
connection:{admit:()=>({})},tools:{register:()=>{},guard:()=>{}},
webServer:{register:route=>routes.set(route.path,route.handler)},
workspaceRegistry:{create:async()=>({id:'workspace'})},
sessionController:{
selectModel:async()=>{assert.fail('Automatic diagnosis must not save the global default');},
create:async({sessionId=randomUUID()}={})=>{
if(nextCreate){const wait=nextCreate;nextCreate=null;await wait.promise;}
const idle=deferred(),rows=[];
const pending=[];
sessions.set(sessionId,{idle,rows,pending,wakeRequested:false,session:{snapshotEvents:()=>rows},whenIdle:()=>idle.promise,
cancel:(_cause,options={})=>{
cancelled.push(sessionId);
if(!options.keepInbox){pending.length=0;sessions.get(sessionId).wakeRequested=false;}
}});
return {sessionId};
},rename:async()=>{},cancel:async({sessionId})=>{sessions.get(sessionId).cancel({kind:'user'},{keepInbox:true});},
commands:{prompt:async({sessionId})=>{
if(nextPrompt){const wait=nextPrompt;nextPrompt=null;await wait.promise;}
prompts.push(sessionId);
sessions.get(sessionId).pending.push('diagnosis');
sessions.get(sessionId).wakeRequested=true;
}}
},llm:{resolveCallConfig:async selection=>selection},agents:{get:id=>sessions.get(id),
serializeImageAdmission:async(_agent,action)=>action(),
selectForNextRequest:(agent,selection)=>{
const sessionId=[...sessions].find(([_id,item])=>item===agent)[0];
assert.ok(!prompts.includes(sessionId));selected.push({sessionId,...selection});
}}};
let source=await readFile(new URL('../integration/dsh/task-plugin/host.mjs',import.meta.url),'utf8');
source=source.replace(/^import .*;\r?\n/gm,'').replace(/export /g,'');
const sandbox={path,randomUUID,createHash,Date:class extends Date{static now(){return now;}},
setTimeout:(callback,ms)=>{latestTimeout=callback;timeouts.push(ms);return setTimeout(callback,ms);},clearTimeout,console,
readFile:async()=>JSON.stringify(context),appendFile:async()=>{},readdir:async()=>[],
lstat:async()=>({isFile:()=>true,isSymbolicLink:()=>false,size:0}),
mkdir:async()=>{},
writeFile:async()=>{if(publicationFailure==='write')throw Error('fixture snapshot write failed');},
rename:async()=>{if(publicationFailure==='rename')throw Error('fixture snapshot rename failed');},
unlink:async filename=>{publicationCleanup.push(filename);},defineTool:value=>value,
registerRuntimeUsage:async()=>({dispose:()=>{},snapshot:()=>({settings:{response_timeout_seconds:90}})}),
registerLifecycle:()=>{},lifecycleNames:[],registerFileTools:()=>{},fileToolNames:[],modelSnapshot:value=>value,
process:{env:{DX_DSH_HOME:'controlled',DX_DSH_WORKSPACE:'controlled'},stdout:{write:line=>{
if(line.startsWith('DX_DSH_DIAGNOSIS '))events.push(JSON.parse(line.slice('DX_DSH_DIAGNOSIS '.length)));
}}}};
vm.createContext(sandbox);
vm.runInContext(source+'\nglobalThis.applyPlugin=apply;',sandbox);
await sandbox.applyPlugin(ctx);
const start=(id,options={})=>handlers.get('dx/diagnose-request')({request_id:id,incident_id:createHash('sha256').update(id).digest('hex').slice(0,24),
phase:'diagnose',snapshot:{task_id:''},evidence:'controlled fixture',...options});
const waitFor=async predicate=>{for(let i=0;i<100&&!predicate();i++)await tick();assert.ok(predicate(),'expected lifecycle event');};
const terminal=id=>events.find(event=>event.request_id===id&&['completed','cancelled','failed'].includes(event.status));
start('cancel-active');start('keep-active',{model_selection:{provider:'configured',model:'saved-model',reasoningEffort:'high'}});
await waitFor(()=>prompts.length===2);
const first=events.find(event=>event.request_id==='cancel-active'&&event.status==='started').session_id;
const other=events.find(event=>event.request_id==='keep-active'&&event.status==='started').session_id;
assert.equal(selected.length,1,'automatic session must use the same configured model as readiness');
assert.equal(selected[0].sessionId,other);
assert.equal(selected[0].provider,'configured');
assert.equal(selected[0].model,'saved-model');
assert.equal(selected[0].reasoningEffort,'high');
handlers.get('dx/diagnose-cancel')({request_id:'unknown'});
assert.deepEqual(cancelled,[]);
handlers.get('dx/diagnose-cancel')({request_id:'cancel-active'});
await waitFor(()=>terminal('cancel-active'));
assert.equal(terminal('cancel-active').status,'cancelled');
assert.deepEqual(cancelled,[first]);
assert.equal(terminal('keep-active'),undefined);
sessions.get(other).rows.push({type:'assistant/message',data:{message:{content:[{type:'text',text:'{"action":"none"}'}]}}});
sessions.get(other).idle.resolve();
await waitFor(()=>terminal('keep-active'));
assert.equal(terminal('keep-active').status,'completed');
nextCreate=deferred();const creating=nextCreate;
start('cancel-creating');
handlers.get('dx/diagnose-cancel')({request_id:'cancel-creating'});
creating.resolve();
await waitFor(()=>terminal('cancel-creating'));
assert.equal(terminal('cancel-creating').status,'cancelled');
assert.equal(prompts.length,2,'cancel during session creation must never enqueue a prompt');
nextPrompt=deferred();const admitting=nextPrompt;
start('cancel-admitting');
await waitFor(()=>events.some(event=>event.request_id==='cancel-admitting'&&event.status==='started'));
const admittingSession=events.find(event=>event.request_id==='cancel-admitting'&&event.status==='started').session_id;
handlers.get('dx/diagnose-cancel')({request_id:'cancel-admitting'});
await waitFor(()=>terminal('cancel-admitting'));
assert.equal(terminal('cancel-admitting').status,'cancelled');
admitting.resolve();
await waitFor(()=>cancelled.filter(id=>id===admittingSession).length===2);
assert.ok(prompts.includes(admittingSession),'fixture admitted the delayed prompt');
assert.equal(sessions.get(admittingSession).pending.length,0,'cancel must clear the late automatic inbox');
assert.equal(sessions.get(admittingSession).wakeRequested,false,'cancelled diagnosis must not wake another turn');
nextPrompt=deferred();const timingOut=nextPrompt;
start('timeout-admitting');
await waitFor(()=>events.some(event=>event.request_id==='timeout-admitting'&&event.status==='started'));
const timeoutSession=events.find(event=>event.request_id==='timeout-admitting'&&event.status==='started').session_id;
latestTimeout();
await waitFor(()=>terminal('timeout-admitting'));
assert.equal(terminal('timeout-admitting').error,'diagnosis_timeout');
timingOut.resolve();
await waitFor(()=>cancelled.filter(id=>id===timeoutSession).length===2);
assert.equal(sessions.get(timeoutSession).pending.length,0,'timeout must clear the late automatic inbox');
nextCreate=deferred();const coldCreate=nextCreate;
const sharedIncident=createHash('sha256').update('shared-budget').digest('hex').slice(0,24);
start('budget-diagnose',{incident_id:sharedIncident,model_budget_ms:180000});
now+=75000;coldCreate.resolve();
await waitFor(()=>events.some(event=>event.request_id==='budget-diagnose'&&event.status==='started'));
assert.equal(timeouts.at(-1),180000,'cold creation must not consume model budget');
const budgetSession=events.find(event=>event.request_id==='budget-diagnose'&&event.status==='started').session_id;
now+=40000;
sessions.get(budgetSession).rows.push({type:'assistant/message',data:{message:{content:[{type:'text',text:'{"action":"none"}'}]}}});
sessions.get(budgetSession).idle.resolve();
await waitFor(()=>terminal('budget-diagnose'));
nextPrompt=deferred();const reflectAdmission=nextPrompt;
start('budget-reflect',{incident_id:sharedIncident,phase:'reflect',model_budget_ms:140000});
await waitFor(()=>events.some(event=>event.request_id==='budget-reflect'&&event.status==='started'));
assert.equal(timeouts.at(-1),140000,'reflection must consume the remaining shared budget');
handlers.get('dx/diagnose-cancel')({request_id:'budget-reflect'});
reflectAdmission.resolve();
await waitFor(()=>terminal('budget-reflect'));
for(const boundary of ['write','rename']){
publicationFailure=boundary;
const before=prompts.length,cleanups=publicationCleanup.length,id='snapshot-'+boundary+'-failure';
start(id);
await waitFor(()=>terminal(id));
assert.equal(terminal(id).status,'failed');
assert.equal(terminal(id).error,'native_diagnosis_failed');
assert.equal(prompts.length,before,'Snapshot publication failure must not admit a model prompt');
assert.ok(!events.some(event=>event.request_id===id&&event.status==='started'));
assert.equal(publicationCleanup.length,cleanups+1,'Failed publication releases its temporary file');
publicationFailure=null;
}
async function action(revision){
const req={method:'POST',async *[Symbol.asyncIterator](){yield JSON.stringify({action:'cancel_diagnosis',task_id:'',revision});}};
const res={status:200,writeHead(code){this.status=code;},end(){},setHeader(){}};
await routes.get('/dx/action')(req,res);return res.status;
}
assert.equal(await action('stale'),409);
assert.equal(await action('current'),200,'taskless incidents must remain cancellable');
console.log('PASS native diagnosis cancellation, session isolation, creation race, publication failures and action revision checks');