Core regression / Python core, intervention UI and release configuration (push) Successful in 16m20s
Core regression / JavaScript syntax (push) Successful in 11s
Core regression / Python core, intervention UI and release configuration (pull_request) Failing after 11m11s
Core regression / JavaScript syntax (pull_request) Successful in 7s
162 lines
12 KiB
JavaScript
162 lines
12 KiB
JavaScript
/** Real Harness, two processes: automatic diagnosis must stay isolated after restart. */
|
|
import {executeTool} from './dsh_tool_probe.mjs';
|
|
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={})=>executeTool(ctx, {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);}
|
|
}
|