deadbyte-mcp 0.15.34 → 0.15.35

package/test/r58-session-lock.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp} from 'node:fs/promises';
+import path from 'node:path';
+import {spawn} from 'node:child_process';
+import {setTimeout as delay} from 'node:timers/promises';
+import {acquireForegroundSessionLock} from '../src/foreground-session-lock.mjs';
+
+test('R58 startup lock excludes competitors and releases after owner hard death without stale lockfiles',{timeout:15000},async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'session-lock-'));
+ const powershell=path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe');
+ const moduleUrl=new URL('../src/foreground-session-lock.mjs',import.meta.url).href;
+ const script=`const {acquireForegroundSessionLock}=await import(${JSON.stringify(moduleUrl)});await acquireForegroundSessionLock(${JSON.stringify({root,powershell})});console.log('OWNER_LOCK_READY');process.stdin.resume();`;
+ const owner=spawn(process.execPath,['--input-type=module','-e',script],{windowsHide:true,stdio:['pipe','pipe','pipe']});let stdout='',stderr='';
+ owner.stdout.on('data',b=>{stdout+=b;});owner.stderr.on('data',b=>{stderr+=b;});const exited=new Promise(resolve=>owner.once('exit',resolve));
+ let lock;
+ try{
+  const until=Date.now()+4000;while(!stdout.includes('OWNER_LOCK_READY')&&owner.exitCode===null&&Date.now()<until)await delay(20);
+  assert.match(stdout,/OWNER_LOCK_READY/,stderr);
+  await assert.rejects(acquireForegroundSessionLock({root,powershell}),/already claimed/);
+  owner.kill('SIGKILL');await exited;
+  const deadline=Date.now()+5000;
+  while(Date.now()<deadline){try{lock=await acquireForegroundSessionLock({root,powershell});break;}catch(error){if(!/already claimed/.test(error.message))throw error;await delay(20);}}
+  assert.ok(lock,'dead owner must not require manual lockfile removal');lock.assertHeld();await lock.release();lock=null;
+ }finally{if(owner.exitCode===null&&owner.signalCode===null)owner.kill();if(lock)await lock.release();}
+});

package/test/r58-stale-owner.test.mjs

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+
+test('R58 inconsistent owner PID binding cannot trigger stale-session authority cleanup', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'owner-binding-'));await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
+ const trace=path.join(root,'trace.txt');
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ const identity=queryForegroundIdentity(process.pid);
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,session_nonce:'c'.repeat(64),owner_identity:{...identity,pid:process.pid+1}};
+ const markerPath=path.join(root,'runtime','remote-session.json');const bytes=JSON.stringify(marker);await writeFile(markerPath,bytes);
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stderr='';child.stderr.on('data',b=>{stderr+=b;});child.stdout.resume();
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stderr}),{flag:'wx'});
+ assert.notEqual(code,0);assert.match(stderr,/ownership identity|binding/i);
+ assert.equal(await readFile(trace,'utf8').catch(e=>e.code==='ENOENT'?'':Promise.reject(e)),'','inconsistent marker must cause no controller actions');
+ assert.equal(await readFile(markerPath,'utf8'),bytes,'retain ambiguous ownership evidence');
+});
+
+test('R58 live unrelated PID is not accepted as a remote foreground owner', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+ await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'stale-owner-'));
+ await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
+ const trace=path.join(root,'trace.txt');
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ // The test runner is alive but neither a remote CLI nor a guardian. This
+ // represents a stale numeric PID now occupied by an unrelated process.
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'a'.repeat(64),started_at_utc:'2000-01-01T00:00:00.000Z'};
+ await writeFile(path.join(root,'runtime','remote-session.json'),JSON.stringify(marker));
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stdout='',stderr='';child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stdout,stderr}),{flag:'wx'});
+ assert.doesNotMatch(stderr,/remote session already active pid=/,'PID alone is not ownership proof');
+ // Fail-closed ambiguity is acceptable; do not kill the unrelated process or
+ // mutate authority based on unverified ownership. Automatic convergence still
+ // requires separately observed exact owner/guardian identity evidence.
+ assert.match(stderr,/identity|ownership|ambiguous|unverified/i);
+ assert.deepEqual(JSON.parse(await readFile(path.join(root,'runtime','remote-session.json'),'utf8')),marker);
+ assert.notEqual(code,0);
+});
+
+test('R58 bound stale birth identity reconciles on the first invocation without killing a reused PID', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+ await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'stale-birth-'));
+ await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
+ const trace=path.join(root,'trace.txt');
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ const current=queryForegroundIdentity(process.pid);
+ const stale={...current,creation_utc:'2000-01-01T00:00:00.000Z'};
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'b'.repeat(64),owner_identity:stale,guardian_identity:stale};
+ const markerPath=path.join(root,'runtime','remote-session.json');
+ await writeFile(markerPath,JSON.stringify(marker));
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stdout='',stderr='';child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stdout,stderr,simulation:'birth identity drift at a live unrelated numeric PID'}),{flag:'wx'});
+ assert.match(stdout,/Stale remote session/);
+ assert.doesNotMatch(stderr,/already active|ownership unverified/);
+ assert.deepEqual((await readFile(trace,'utf8')).trim().split(/\r?\n/).slice(0,6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+ assert.match(stderr,/without a verified ONLINE runtime/,'fixture deliberately has no real runtime; recovery must already have converged');
+ await assert.rejects(readFile(markerPath),{code:'ENOENT'});
+ assert.equal(foregroundAlive(),true,'unrelated live process must not be killed');
+ function foregroundAlive(){try{process.kill(process.pid,0);return true;}catch{return false;}}
+});

package/test/r58-windows-gate.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+
+test('R58 canonical Windows gate is final-candidate bound and leaves historical gates immutable',async()=>{
+  const [pkgText,gate,evidence,r57Gate,r57Evidence]=await Promise.all([
+    read('package.json'),read('scripts/gate-windows-r58.ps1'),read('scripts/windows-gate-evidence-r58.mjs'),
+    read('scripts/gate-windows-r57.ps1'),read('scripts/windows-gate-evidence-r57.mjs')
+  ]);
+  const pkg=JSON.parse(pkgText);
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r58\.ps1$/);
+  assert.match(pkg.scripts['r58:focused:test'],/scripts\/r58-focused\.ps1$/);
+  assert.match(pkg.scripts['r58:cross-plane:test'],/scripts\/r58-cross-plane\.ps1$/);
+  assert.match(gate,/DEADBYTE 0\.15\.35 \/ R58 WINDOWS GATE: PASS/);
+  assert.match(gate,/r58-package-boundary/);
+  assert.match(gate,/r58-process-policy/);
+  assert.match(gate,/r58-focused-contracts/);
+  assert.match(gate,/full_regression\.status -ne 'PASS'/);
+  assert.match(evidence,/deadbyte\.r58-windows-gate\.v1/);
+  assert.match(evidence,/pkg\.version==='0\.15\.35'/);
+  assert.match(evidence,/release\.train==='R58'/);
+  assert.match(evidence,/release\.parent\?\.version==='0\.15\.34'/);
+  assert.match(evidence,/health\.assessment!==['"]FAIL['"]/);
+  assert.match(evidence,/\['ok','warn'\]\.includes\(health\.status\)/);
+  assert.match(evidence,/four_hour_soak_completed:false/);
+  assert.match(evidence,/clean_machine_completed:false/);
+  assert.match(r57Gate,/DEADBYTE 0\.15\.34 \/ R57 WINDOWS GATE: PASS/);
+  assert.match(r57Evidence,/deadbyte\.r57-windows-gate\.v1/);
+});

package/test/release-generation.test.mjs

@@ -35,7 +35,7 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   await writeFile(semanticConfigPath,semanticConfigBytes);
   const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,DesktopRuntimeEnabled:true,AutonomousRuntimeEnabled:true,AutonomousSupervisorEnabled:true,SemanticLspConfigFile:semanticConfigPath,SemanticLspConfigSha256:sha(semanticConfigBytes),
     Supervisor:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'src\\autonomous-supervisor-host.mjs',WorkingDirectory:'C:/release',ScriptPath:'C:/release/src/autonomous-supervisor-host.mjs',ScriptSha256:'2'.repeat(64)},
-    Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE},
+    Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE,Dependencies:[{Name:'bridge-validator',Path:'C:/bridge/public-tool-definitions.mjs',Sha256:EXE}]},
     Cloud:{FilePath:'C:/deadbyte-tunnel-host.exe',FileSha256:EXE,Arguments:'"C:/cloudflared.exe" "C:/secret/tunnel-token.txt" "C:/bridge"',WorkingDirectory:'C:/release',Transport:'deadbyte.named-tunnel.v2',Dependencies:[
       {Name:'cloudflared',Path:'C:/cloudflared.exe',Sha256:EXE},{Name:'tunnel-token',Path:'C:/secret/tunnel-token.txt',Sha256:EXE}
     ]},
@@ -70,6 +70,9 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const build=args=>createGenerationBundle({...args,systemRoot});
   const result=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
+  const bridgeConfig=await readFile(result.config_path,'utf8');
+  const bridgeBlock=bridgeConfig.slice(bridgeConfig.indexOf('    Bridge = @{'),bridgeConfig.indexOf('    Cloud = @{'));
+  assert.match(bridgeBlock,/Name = 'bridge-validator'; Path = 'C:\/bridge\/public-tool-definitions.mjs'; Sha256 = '1{64}'/,'generation must not discard explicitly pinned Bridge dependencies');
   assert.equal(verified.files,7);
   const generatedProcess=JSON.parse(await readFile(result.process_policy_path,'utf8'));
   assert.equal(generatedProcess.grant_file,path.join(path.resolve(state),'runtime','process-grant.json'));

package/test/remote-session-cli.test.mjs

@@ -401,7 +401,60 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
   }
 });
 
-winTest('bare remote refuses a second live foreground session without touching authority',async()=>{
+winTest('R58 concurrent cold remote claims have one winner and no loser cleanup',async()=>{
+  const fx=await fixture({statusOnline:true});const children=[],outputs=[];
+  try{
+    for(let i=0;i<3;i++){
+      const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+      children.push(child);outputs.push(await collect(child));
+    }
+    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
+    assert.ok(commands.includes('hoststatus'),outputs.map(o=>o.stderr).join('\n'));
+    const deadline=Date.now()+5000;
+    while(Date.now()<deadline&&children.filter(c=>c.exitCode===null).length>1)await sleep(50);
+    const live=children.filter(c=>c.exitCode===null);
+    assert.equal(live.length,1,'exactly one verified foreground may survive');
+    const trace=await traceCommands(fx.trace);
+    for(const arm of ['armprocess','armcoding','armautonomous'])assert.equal(trace.filter(x=>x===arm).length,1);
+    assert.ok(!trace.some(x=>x.startsWith('disarm')||x==='park'),'losers must not revoke winner authority');
+    for(let i=0;i<children.length;i++)if(children[i]!==live[0])assert.match(outputs[i].stderr,/remote session already (claimed|active)/,'concurrent rejection must have deterministic ownership vocabulary');
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    assert.equal(marker.owner_pid,live[0].pid);
+    live[0].stdin.end();assert.equal((await outputs[children.indexOf(live[0])].closed).code,0);
+  }finally{
+    for(const child of children)if(child.exitCode===null)child.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('R58 duplicate remote verifies the real live owner and leaves its authority untouched',async()=>{
+  const fx=await fixture({statusOnline:true});let first=null,second=null;
+  try{
+    first=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const firstOutput=await collect(first);
+    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
+    assert.ok(commands.includes('hoststatus'),firstOutput.stderr);
+    const before=await traceCommands(fx.trace);
+    const markerPath=path.join(fx.state,'runtime','remote-session.json');
+    const marker=JSON.parse(await readFile(markerPath,'utf8'));
+    assert.equal(marker.owner_identity.pid,first.pid);
+    assert.equal(marker.guardian_identity.parent_pid,first.pid);
+    second=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const secondOutput=await collect(second);
+    const stopped=await secondOutput.closed;
+    assert.notEqual(stopped.code,0);
+    assert.match(secondOutput.stderr,/remote session already active/);
+    assert.deepEqual(await traceCommands(fx.trace),before,'duplicate must not run any controller operation');
+    assert.deepEqual(JSON.parse(await readFile(markerPath,'utf8')),marker);
+    assert.equal(first.exitCode,null,'verified legitimate foreground must survive');
+    first.stdin.end();assert.equal((await firstOutput.closed).code,0,firstOutput.stderr);
+  }finally{
+    if(first?.exitCode===null)first.kill();if(second?.exitCode===null)second.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('bare remote refuses unverified legacy ownership without touching authority',async()=>{
   const fx=await fixture();
   let child=null;
   try{
@@ -416,7 +469,7 @@ winTest('bare remote refuses a second live foreground session without touching a
     assert.equal(ended.timeout,undefined);
     assert.notEqual(ended.code,0);
     assert.deepEqual(await traceCommands(fx.trace),[]);
-    assert.match(output.stderr,/remote session already active/i);
+    assert.match(output.stderr,/remote session ownership unverified/i);
   }finally{
     if(child?.exitCode===null) child.kill();
     await rm(fx.dir,{recursive:true,force:true});