deadbyte-mcp 0.15.50 → 0.15.52

package/test/r135-autonomous-scope.test.mjs

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,rm,readFile,writeFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+import {assertAutonomousBootstrapRoots} from '../src/runtime-update.mjs';
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+async function fixture(run){
+ const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r135-scope-'));
+ try{
+  const core=path.join(base,'safe-project'),scratch=path.join(base,'child-state');
+  await mkdir(core);await mkdir(scratch);
+  const original={schema:'deadbyte.coding-policy.v1',enabled:true,
+   lease_file:path.join(base,'parent-coding-grant.json'),
+   evidence_dir:path.join(base,'parent-evidence'),
+   roots:{core:{path:core,read:true,write:true,exec:true,deny_paths:[]},
+    local_c:{path:path.parse(base).root,read:true,write:true,exec:true,deny_paths:[]},
+    downloads:{path:path.join(base,'downloads'),read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{executable:'node',args:[],root_ids:['core','local_c']},unused_command:{executable:'cmd',args:[],root_ids:['local_c']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(base,'parent-autonomous-grant.json'),evidence_dir:path.join(base,'old-auto-evidence'),
+    coding_policy_sha256:'a'.repeat(64),root_ids:['core'],
+    planner:{backend:'client_sampling',max_tokens:2048},
+    profiles:{quick:{kind:'command',root_id:'core',command_id:'node_script',
+     script_path:'test.mjs',script_sha256:'b'.repeat(64)}}};
+  await run({base,core,scratch,original,autonomous});
+ }finally{await rm(base,{recursive:true,force:true})}
+}
+test('R135 projects only the chosen project root and its pinned commands without modifying manual Coding',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const before=JSON.stringify(original),beforeAutonomous=JSON.stringify(autonomous);
+  const result=deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:scratch});
+  assert.deepEqual(Object.keys(result.codingPolicy.roots),['core']);
+  assert.deepEqual(Object.keys(result.codingPolicy.commands),['node_script']);
+  assert.equal(result.autonomousPolicy.coding_policy_sha256,hash(result.codingBytes));
+  assert.deepEqual(result.autonomousPolicy.root_ids,['core']);
+  assert.deepEqual(assertAutonomousBootstrapRoots(result.autonomousPolicy,result.codingPolicy,hash(result.codingBytes)),['core']);
+  assert.equal(JSON.stringify(original),before);
+  assert.equal(JSON.stringify(autonomous),beforeAutonomous);
+  assert.notEqual(result.codingPolicy.lease_file,original.lease_file);
+  assert.notEqual(result.autonomousPolicy.lease_file,autonomous.lease_file);
+  await assert.rejects(()=>readFile(result.codingPolicy.lease_file),{code:'ENOENT'});
+  await assert.rejects(()=>readFile(result.autonomousPolicy.lease_file),{code:'ENOENT'});
+ });
+});
+test('R135 scope projector refuses direct whole-drive root and does not weaken R70 security gate',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const wide={...autonomous,root_ids:['local_c'],
+   profiles:{quick:{...autonomous.profiles.quick,root_id:'local_c'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:wide,
+   scopeRootId:'local_c',isolatedStateRoot:scratch}),/project-scoped root/);
+  assert.throws(()=>assertAutonomousBootstrapRoots(autonomous,original,'a'.repeat(64)),
+   /coding policy contains a broad filesystem root/);
+ });
+});
+test('R135 rejects Autonomous profiles targeting roots other than the approved scope',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const forged={...autonomous,profiles:{out:{...autonomous.profiles.quick,root_id:'downloads'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:forged,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/profile.*outside/);
+ });
+});
+test('R135 rejects missing command referenced by approved profile',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const forged={...autonomous,profiles:{quick:{...autonomous.profiles.quick,command_id:'not_allowlisted'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:forged,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/command.*missing/);
+ });
+});
+test('R135 refuses missing, redirected, and unsafe project root',async()=>{
+ await fixture(async({scratch,original,autonomous,base})=>{
+  original.roots.core.path=path.join(base,'not-present');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/real project directory/);
+ });
+});
+test('R135 does not accept an isolated state ancestor of an existing manual lease',async()=>{
+ await fixture(async({scratch,original,autonomous,base})=>{
+  original.lease_file=path.join(base,'runtime','existing-coding-grant.json');
+  autonomous.lease_file=path.join(path.dirname(base),'other-autonomous-grant.json');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+    scopeRootId:'core',isolatedStateRoot:base}),/isolated state root overlaps manual Coding lease/);
+ });
+});
+test('R135 does not inherit any existing grant file at the isolated destination',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const runtime=path.join(scratch,'runtime');
+  await mkdir(runtime);
+  await writeFile(path.join(runtime,'coding-grant.json'),'{"legacy":true}\n');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+    scopeRootId:'core',isolatedStateRoot:scratch}),/isolated grant file already present/);
+ });
+});
+
+test('R135 refuses using the manual lease root as the isolated runtime root',async()=>{
+ await fixture(async({original,autonomous,base})=>{
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:base}),/isolated state root overlaps manual Coding lease/);
+ });
+});

package/test/r136-scoped-command-rights.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+const fixture=async fn=>{
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r136-command-'));
+ try{
+  const core=path.join(dir,'core'),state=path.join(dir,'isolated');
+  await mkdir(core);await mkdir(state);
+  const coding={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(dir,'manual','coding-grant.json'),
+   evidence_dir:path.join(dir,'manual','evidence'),roots:{core:{path:core,read:true,write:true,exec:true,deny_paths:[]},
+    local_c:{path:path.parse(dir).root,read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:'a'.repeat(64),
+    root_ids:['core','local_c'],prefix_args:[],extensions:['.mjs']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:path.join(dir,'manual','autonomous-grant.json'),
+   evidence_dir:path.join(dir,'manual','evidence-auto'),coding_policy_sha256:'b'.repeat(64),
+   root_ids:['core'],profiles:{quick:{root_id:'core',command_id:'node_script'}},
+   planner:{backend:'client_sampling'}};
+  await fn({coding,autonomous,state});
+ } finally {await rm(dir,{recursive:true,force:true})}
+};
+test('R136 projected command does not retain broad manual root_ids',async()=>{
+ await fixture(({coding,autonomous,state})=>{
+  const before=structuredClone(coding);
+  const result=deriveIsolatedAutonomousScope({manualCodingPolicy:coding,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:state});
+  assert.deepEqual(result.codingPolicy.commands.node_script.root_ids,['core']);
+  assert.deepEqual(coding,before);
+ });
+});
+test('R136 command with no access to approved scope fails closed',async()=>{
+ await fixture(({coding,autonomous,state})=>{
+  coding.commands.node_script.root_ids=['local_c'];
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:coding,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:state}),/command.*outside approved scope/);
+ });
+});

package/test/r136-scoped-observer.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile,rm} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import {startScopedObserver} from '../src/scoped-observer-launcher-r136.mjs';
+import {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function prepared(run){
+ const temp=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r136-observer-'));
+ let observer=null;
+ try{
+  const project=path.join(temp,'project'),isolated=path.join(temp,'isolated');
+  await mkdir(project);await mkdir(isolated);
+  const manual={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(temp,'manual','coding-grant.json'),
+   evidence_dir:path.join(temp,'manual','evidence'),
+   roots:{core:{path:project,read:true,write:true,exec:true,deny_paths:[]},
+    local_d:{path:path.parse(temp).root,read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{kind:'script',root_ids:['core','local_d'],executable:process.execPath,
+    executable_sha256:'a'.repeat(64),prefix_args:[],extensions:['.mjs']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+   lease_file:path.join(temp,'manual','autonomous-grant.json'),evidence_dir:path.join(temp,'manual','aevidence'),
+   coding_policy_sha256:'f'.repeat(64),root_ids:['core'],
+   planner:{backend:'client_sampling'},profiles:{quick:{kind:'command',root_id:'core',command_id:'node_script'}}};
+  const projected=deriveIsolatedAutonomousScope({manualCodingPolicy:manual,autonomousPolicy:autonomous,scopeRootId:'core',isolatedStateRoot:isolated});
+  const codingFile=path.join(isolated,'coding-policy.json'),autonomousFile=path.join(isolated,'autonomous-policy.json');
+  await writeFile(codingFile,projected.codingBytes);
+  await writeFile(autonomousFile,projected.autonomousBytes);
+  const options={stateRoot:isolated,codingPolicyFile:codingFile,autonomousPolicyFile:autonomousFile,
+   codingSha256:projected.coding_sha256,autonomousSha256:projected.autonomous_sha256};
+  await run({temp,isolated,options,projected,manual,autonomous,setObserver:v=>observer=v});
+ } finally {
+  if(observer)await observer.close();
+  await rm(temp,{recursive:true,force:true});
+ }
+}
+test('R136 observer starts in its own PID disarmed, with no inherited broad Coding policy or ambient secrets',async()=>{
+ await prepared(async({options,projected,setObserver})=>{
+  const obs=await startScopedObserver({...options, ambientEnv:{DEADBYTE_CODING_POLICY:'C:\\\\evil.json',
+   DEADBYTE_STATE_ROOT:'C:\\\\Users\\\\DEADBYTE\\\\.deadbyte-mcp',NODE_OPTIONS:'--inspect',
+   OPENAI_API_KEY:'DO_NOT_LEAK'}});
+  setObserver(obs);
+  const result=obs.ready;
+  assert.ok(Number.isInteger(result.pid)&&result.pid>0);
+  assert.notEqual(result.pid,process.pid);
+  assert.equal(result.status,'DISARMED');
+  assert.deepEqual(result.root_ids,['core']);
+  assert.deepEqual(result.command_ids,['node_script']);
+  assert.equal(result.coding_sha256,projected.coding_sha256);
+  assert.equal(result.autonomous_sha256,projected.autonomous_sha256);
+  assert.equal(result.ambient_deadbyte_keys,0);
+  assert.equal(result.node_options_present,false);
+  assert.equal(result.user_token_present,false);
+  assert.equal(result.grant_files_present,false);
+ });
+});
+test('R136 observer refuses execute, arm and privileged requests instead of invoking any host tool',async()=>{
+ await prepared(async({options,setObserver})=>{
+  const obs=await startScopedObserver(options);setObserver(obs);
+  for(const action of ['execute','arm','write','host_exec','unknown']){
+   const reply=await obs.request({op:action,root_id:'core',command_id:'node_script'});
+   assert.deepEqual(reply,{status:'DENIED_UNAUTHORIZED',op:action});
+  }
+  assert.deepEqual(await obs.request({op:'status'}),{status:'DISARMED',root_ids:['core']});
+ });
+});
+test('R136 client-controlled IPC envelope fields cannot override request identity',async()=>{
+ await prepared(async({options,setObserver})=>{
+  const obs=await startScopedObserver(options);setObserver(obs);
+  const result=await obs.request({kind:'reply',id:9999,op:'execute'});
+  assert.deepEqual(result,{status:'DENIED_UNAUTHORIZED',op:'execute'});
+ });
+});
+
+test('R136 observer rejects policy byte tampering against SHA-pinned startup',async()=>{
+ await prepared(async({options})=>{
+  await writeFile(options.codingPolicyFile,Buffer.concat([await readFile(options.codingPolicyFile),Buffer.from(' ')]));
+  await assert.rejects(startScopedObserver(options),/policy digest mismatch|observer boot failed/);
+ });
+});
+test('R136 observer refuses inherited grant bytes even when policy hashes match',async()=>{
+ await prepared(async({options,isolated})=>{
+  const dir=path.join(isolated,'runtime');await mkdir(dir,{recursive:true});
+  await writeFile(path.join(dir,'coding-grant.json'),Buffer.from('{"armed":true}\n'));
+  await assert.rejects(startScopedObserver(options),/grant present|observer boot failed/);
+ });
+});

package/test/r137-commander-config-recovery.test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,writeFile,readFile,readdir,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {createHash} from 'node:crypto';
+import {createCommanderExtendedRuntime} from '../src/commander-extended-runtime.mjs';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+async function fixture(run){
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r137-config-'));
+ try{await run({root,file:path.join(root,'commander-config.json')});}
+ finally{await rm(root,{recursive:true,force:true});}
+}
+test('R137 recovers bounded display limits from complete JSON prefix, not privileges or telemetry',async()=>{
+ await fixture(async({root,file})=>{
+  const corrupt=Buffer.from('{"fileReadLineLimit":200,"fileWriteLineLimit":20,"allowedDirectories":["C:\\\\","D:\\\\"],"telemetryEnabled":true,"defaultShell":"cmd.exe","theme":"light","blockedCommands":[],"damaged": [\n','utf8');
+  await writeFile(file,corrupt);
+  const runtime=createCommanderExtendedRuntime({stateRoot:root});
+  const cfg=await runtime.getConfig();
+  assert.equal(cfg.config.fileReadLineLimit,200);
+  assert.equal(cfg.config.fileWriteLineLimit,20);
+  assert.equal(cfg.config.telemetryEnabled,false);
+  assert.deepEqual(cfg.config.allowedDirectories,[]);
+  assert.equal(cfg.config.theme,undefined);
+  assert.equal(cfg.config.defaultShell,process.platform==='win32'?'powershell.exe':(process.env.SHELL||'/bin/sh'));
+  assert.equal(cfg.recovery?.status,'recovered');
+  assert.deepEqual(cfg.recovery?.salvaged_keys,['fileReadLineLimit','fileWriteLineLimit']);
+  const backups=(await readdir(root)).filter(f=>f.startsWith('commander-config.json.corrupt.'));
+  assert.equal(backups.length,1);
+  assert.equal(sha(await readFile(path.join(root,backups[0]))),sha(corrupt));
+  const stored=JSON.parse(await readFile(file,'utf8'));
+  assert.equal(stored.fileReadLineLimit,200);
+  assert.equal(stored.telemetryEnabled,false);
+  const next=await runtime.getConfig();
+  assert.equal(next.config_sha256,cfg.config_sha256);
+  assert.equal((await readdir(root)).filter(f=>f.startsWith('commander-config.json.corrupt.')).length,1);
+ });
+});
+test('R137 totally corrupt or oversized config recovers minimal defaults without inheriting blockedCommands/paths',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'garbled not JSON');
+  const config=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(config.recovery?.status,'recovered');
+  assert.deepEqual(config.recovery?.salvaged_keys,[]);
+  assert.deepEqual(config.config.allowedDirectories,[]);
+  assert.equal(config.config.telemetryEnabled,false);
+  assert.ok(!Object.hasOwn(config.config,'arbitraryAuthority'));
+ });
+});
+test('R137 ignores out-of-bounds limits in parseable prefix',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"fileReadLineLimit":999999,"fileWriteLineLimit":0,"allowedDirectories":["C:\\\\"],"broken":');
+  const config=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(config.config.fileReadLineLimit,1000);
+  assert.equal(config.config.fileWriteLineLimit,50);
+  assert.deepEqual(config.recovery?.salvaged_keys,[]);
+ });
+});
+test('R137 parallel configuration reads share one recovery and preserve original backup',async()=>{
+ await fixture(async({root,file})=>{
+  const raw=Buffer.from('{"fileReadLineLimit":210,"allowedDirectories":["C:\\\\"],"unfinished": [\n');
+  await writeFile(file,raw);
+  const rt=createCommanderExtendedRuntime({stateRoot:root});
+  const [a,b,c]=await Promise.all([rt.getConfig(),rt.getConfig(),rt.getConfig()]);
+  assert.deepEqual([a.config_sha256,b.config_sha256,c.config_sha256],[a.config_sha256,a.config_sha256,a.config_sha256]);
+  const backups=(await readdir(root)).filter(n=>n.startsWith('commander-config.json.corrupt.'));
+  assert.equal(backups.length,1);
+  assert.equal(sha(await readFile(path.join(root,backups[0]))),sha(raw));
+ });
+});
+test('R137 quoted commas and nested JSON do not spoof a recoverable top-level setting',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"description":"x, \\\"fileReadLineLimit\\\": 8","nested":{"fileReadLineLimit":1},"fileReadLineLimit":225,"bad": [');
+  const r=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(r.config.fileReadLineLimit,225);
+  assert.deepEqual(r.recovery?.salvaged_keys,['fileReadLineLimit']);
+ });
+});
+test('R137 valid non-object JSON is not trusted as configuration',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'["allowedDirectories","C:\\\\"]');
+  const r=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(r.recovery?.status,'recovered');
+  assert.deepEqual(r.config.allowedDirectories,[]);
+ });
+});
+
+test('R137 preserves the existing valid config without making recovery backup',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,JSON.stringify({theme:'classic',telemetryEnabled:false}));
+  const result=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(result.config.theme,'classic');
+  assert.equal(result.recovery,undefined);
+  assert.deepEqual(await readdir(root),['commander-config.json']);
+ });
+});
+test('R137 recovered config remains hash-preconditioned for subsequent edits',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"fileReadLineLimit":333,"bad":[');
+  const runtime=createCommanderExtendedRuntime({stateRoot:root});
+  const first=await runtime.getConfig();
+  await assert.rejects(runtime.setConfigValue({key:'theme',value:'classic',expected_sha256:'0'.repeat(64)}),/precondition/);
+  const done=await runtime.setConfigValue({key:'theme',value:'classic',expected_sha256:first.config_sha256});
+  assert.equal(done.status,'committed');
+  const fresh=createCommanderExtendedRuntime({stateRoot:root});
+  const now=await fresh.getConfig();
+  assert.equal(now.config.theme,'classic');
+  assert.equal(now.config.fileReadLineLimit,333);
+  assert.equal(now.recovery,undefined);
+ });
+});

package/test/r137-commander-three-version-contract.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import {pathToFileURL} from 'node:url';
+import path from 'node:path';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
+
+const base='D:\\Projects\\deadbyte-mcp\\references';
+const fixtures=[
+ {version:'0.2.52',relative:'desktop-commander v0.2.52/dist/tools/schemas.js',sha256:'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140',tools:27},
+ {version:'0.3.0',relative:'desktop-commander v0.3.0/dist/tools/schemas.js',sha256:'7d4c62e2099d757d8fba68011cfe25d3088426f56c0b77d5b8fa3edb4ec49c2c',tools:26},
+ {version:'0.3.1-alpha.2',relative:'desktop-commander-0.3.1-alpha.2/static/dist/tools/schemas.js',sha256:'6a290497b29f9dc5f43d66008ea54fcf0c302edea5612af519ef52ab3816d29e',tools:27}
+];
+const known={
+ get_config:{},set_config_value:{key:'theme',value:'classic'},read_file:{path:'x'},read_multiple_files:{paths:['x']},
+ write_file:{path:'x',content:'v'},write_pdf:{path:'x',content:'# x'},create_directory:{path:'x'},
+ list_directory:{path:'x'},move_file:{source:'a',destination:'b'},start_search:{path:'.',pattern:'x'},
+ get_more_search_results:{sessionId:'s'},stop_search:{sessionId:'s'},list_searches:{},get_file_info:{path:'x'},
+ edit_block:{file_path:'x',old_string:'a',new_string:'b'},start_process:{command:'echo x',timeout_ms:10},
+ read_process_output:{pid:1},interact_with_process:{pid:1,input:'x'},force_terminate:{pid:1},list_sessions:{},
+ list_processes:{},kill_process:{pid:1},get_usage_stats:{},get_recent_tool_calls:{},
+ give_feedback_to_desktop_commander:{},get_prompts:{action:'get_prompt',promptId:'x'}
+};
+const sha=s=>createHash('sha256').update(s).digest('hex');
+const unwrap=o=>{while(o?._def?.schema)o=o._def.schema;return o};
+function candidate(){
+ const v={...createCommanderWireAdapter({}).schemas};
+ registerCommanderExtendedBridge({registerTool(name,def){v[name]=def.inputSchema;}},{extendedRuntime:{}});
+ return v;
+}
+async function reference(f){
+ const bytes=await readFile(path.join(base,f.relative));
+ assert.equal(sha(bytes),f.sha256,'reference source SHA drift: '+f.version);
+ const zod=pathToFileURL(path.resolve('node_modules/zod/v3/index.js')).href;
+ const source=bytes.toString('utf8').replace('from "zod"','from '+JSON.stringify(zod));
+ return (await import('data:text/javascript;base64,'+Buffer.from(source).toString('base64'))).toolArgSchemas;
+}
+for(const fixture of fixtures){
+ test('R137 pinned Desktop Commander '+fixture.version+' public tool schemas remain compatible',async()=>{
+  const r=await reference(fixture),c=candidate();
+  assert.equal(Object.keys(r).length,fixture.tools);
+  if(fixture.version==='0.3.0')assert.equal(Object.hasOwn(r,'get_prompts'),false);
+  for(const [name,refSchema] of Object.entries(r)){
+   // track_ui_event is a deliberately hidden UI dispatch, not a public MCP tool.
+   if(name==='track_ui_event')continue;
+   assert.ok(c[name],'DEADBYTE missing '+name);
+   assert.deepEqual(Object.keys(unwrap(c[name]).shape).sort(),Object.keys(unwrap(refSchema).shape).sort(),name+' property names');
+   const expected=refSchema.safeParse({...known[name],__future_extra:'strip'});
+   const actual=c[name].safeParse({...known[name],__future_extra:'strip'});
+   assert.equal(actual.success,expected.success,name+' input acceptance');
+   if(actual.success)assert.deepEqual(actual.data,expected.data,name+' normalized defaults');
+  }
+ });
+}

package/test/r138-commander-process-pagination.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createCommanderExternalProcessRuntime} from '../src/commander-external-process-r48.mjs';
+
+const snapshot='a'.repeat(64),stamp='2026-10-21T11:00:00.000Z';
+const row=(pid)=>({pid,parent_pid:1,name:'test'+pid+'.exe',ownership:'external',
+ creation_time_utc:stamp,executable_path:null,command_line:null});
+const page=(items,cursor=null,identity=snapshot)=>({status:'ok',snapshot_id:identity,observed_at_utc:stamp,
+ processes:items,next_cursor:cursor,receipt_id:'b'.repeat(24)});
+function fixture(sequence){
+ let index=0;
+ const observationRuntime={async processList(){return sequence[Math.min(index++,sequence.length-1)];}};
+ return {runtime:createCommanderExternalProcessRuntime({observationRuntime}),calls:()=>index};
+}
+test('R138 rejects a repeated external process cursor instead of polling forever',async()=>{
+ const f=fixture([page([row(1)],'repeat'),page([row(2)],'repeat')]);
+ await assert.rejects(f.runtime.list(),/cursor.*repeat|pagination.*cycle/i);
+ assert.equal(f.calls(),2);
+});
+test('R138 rejects duplicate PID across pages instead of creating ambiguous kill target',async()=>{
+ const f=fixture([page([row(42)],'next'),page([row(42)],null)]);
+ await assert.rejects(f.runtime.list(),/duplicate.*PID/i);
+ assert.equal(f.calls(),2);
+});
+test('R138 rejects contradictory observation timestamps across a single snapshot',async()=>{
+ const f=fixture([page([row(1)],'next'),{...page([row(2)]),observed_at_utc:'2026-10-21T12:00:00.000Z'}]);
+ await assert.rejects(f.runtime.list(),/observation time.*changed|timestamp.*changed/i);
+});
+test('R138 rejects invalid missing snapshot identity and unbounded cursor',async()=>{
+ const f=fixture([{...page([row(1)]),snapshot_id:null}]);
+ await assert.rejects(f.runtime.list(),/snapshot.*identity/i);
+ const oversized=fixture([page([row(1)],'x'.repeat(12000))]);
+ await assert.rejects(oversized.runtime.list(),/cursor.*invalid/i);
+});
+test('R138 normal two-page process observation preserves ordered identities and receipts',async()=>{
+ const f=fixture([page([row(1)],'next'),page([row(2)])]);
+ const r=await f.runtime.list();
+ assert.deepEqual(r.processes.map(x=>x.pid),[1,2]);
+ assert.equal(r.snapshot_id,snapshot);
+ assert.deepEqual(r.receipt_ids,['b'.repeat(24)]);
+ assert.equal(f.calls(),2);
+});

package/test/r138-commander-session-list.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+test('R138 Commander sessions show PID, profile, root, and exit outcome in one line',async()=>{
+ const sessions=[
+  {session_id:'a'.repeat(64),child_pid:21138,state:'running',exit_code:null,profile_id:'powershell',root_id:'core',stream_head:17},
+  {session_id:'b'.repeat(64),child_pid:22138,state:'exited',exit_code:7,profile_id:'node',root_id:'build',stream_head:20}
+ ];
+ const a=createCommanderWireAdapter({processRuntime:{async list(){return {sessions}}}});
+ const r=await a.handlers.list_sessions({});
+ assert.equal(r.isError,undefined);
+ assert.deepEqual(r.structuredContent.sessions,sessions);
+ assert.match(r.content[0].text,/PID=21138/);
+ assert.match(r.content[0].text,/PID=22138/);
+ assert.match(r.content[0].text,/exit=7/);
+ assert.match(r.content[0].text,/profile=node/);
+ assert.match(r.content[0].text,/root=build/);
+});
+test('R138 no sessions returns a readable empty summary',async()=>{
+ const a=createCommanderWireAdapter({processRuntime:{async list(){return {sessions:[]}}}});
+ const r=await a.handlers.list_sessions({});
+ assert.match(r.content[0].text,/No managed sessions/);
+ assert.deepEqual(r.structuredContent.sessions,[]);
+});

package/test/r138-commander-stream-resume.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+const saved={profile:process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE,root:process.env.DEADBYTE_COMMANDER_COMPAT_ROOT};
+function fakeProcess({retained='one\ntwo\n',earliest=5,head=13,state='exited'}={}){
+ const bytes=Buffer.from(retained);
+ return {
+  policy:{roots:{core:{real_path:'C:\\\\r138'}}},
+  async start(){return {session_id:'s'.repeat(64),child_pid:18138}},
+  async read({offset,maxBytes}){
+   const start=Math.max(offset,earliest);
+   const data=bytes.subarray(start-earliest,start-earliest+maxBytes);
+   return {offset:start,next_offset:start+data.length,earliest_offset:earliest,stream_head:head,
+    state,exit_code:0,data_base64:data.toString('base64')};
+  },
+  async list(){return {sessions:[]}},
+  async status(){return {state}}
+ };
+}
+async function adapter(proc){
+ process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE='test';
+ process.env.DEADBYTE_COMMANDER_COMPAT_ROOT='core';
+ const rt=createCommanderWireAdapter({processRuntime:proc});
+ await rt.handlers.start_process({command:'echo hi',timeout_ms:1000});
+ return rt;
+}
+test.after(()=>{if(saved.profile===undefined)delete process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE;else process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE=saved.profile;if(saved.root===undefined)delete process.env.DEADBYTE_COMMANDER_COMPAT_ROOT;else process.env.DEADBYTE_COMMANDER_COMPAT_ROOT=saved.root;});
+test('R138 incremental output reports exact byte resume location and dropped prefix explicitly',async()=>{
+ const a=await adapter(fakeProcess());
+ const first=await a.handlers.read_process_output({pid:18138,offset:0,length:1,timeout_ms:0});
+ assert.equal(first.isError,undefined,JSON.stringify(first));
+ assert.equal(first.structuredContent.truncated,true);
+ assert.equal(first.structuredContent.earliest_offset,5);
+ assert.equal(first.structuredContent.next_byte_offset,9);
+ assert.equal(first.structuredContent.more_unread,true);
+ const second=await a.handlers.read_process_output({pid:18138,offset:0,length:1,timeout_ms:0});
+ assert.equal(second.structuredContent.next_byte_offset,13);
+ assert.equal(second.structuredContent.more_unread,false);
+ const third=await a.handlers.read_process_output({pid:18138,offset:0,length:1,timeout_ms:0});
+ assert.equal(third.structuredContent.next_byte_offset,13);
+ assert.equal(third.structuredContent.read_count,0);
+});
+test('R138 historical line offset reads are nonconsuming and declare no byte resume cursor',async()=>{
+ const a=await adapter(fakeProcess());
+ const history=await a.handlers.read_process_output({pid:18138,offset:-1,length:1,timeout_ms:0});
+ assert.equal(history.structuredContent.read_count,1);
+ assert.equal(history.structuredContent.next_byte_offset,null);
+ const initial=await a.handlers.read_process_output({pid:18138,offset:0,length:1,timeout_ms:0});
+ assert.equal(initial.structuredContent.next_byte_offset,9);
+});

package/test/r139-large-text-edit.test.mjs

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+const sha=data=>createHash('sha256').update(data).digest('hex');
+function fake(initial){
+ let current=Buffer.from(initial);let writes=0;
+ const runtime={
+  policy:{roots:{core:{real_path:'D:\\\\R139-EDIT'}},max_read_bytes:64*1024*1024},
+  async read({maxBytes}){
+   const view=current.subarray(0,maxBytes);
+   return {data_base64:view.toString('base64'),file_sha256:sha(current),eof:view.length===current.length,file_size:current.length};
+  },
+  async write({content,encoding,expectedSha256}){
+   assert.equal(expectedSha256,sha(current));
+   const next=encoding==='utf8'?Buffer.from(content):Buffer.from(content,'base64');
+   current=next;writes++;
+   return {sha256:sha(next),receipt_id:'r139-test'};
+  }
+ };
+ return {runtime,writes:()=>writes,current:()=>current};
+}
+test('R139 edit_block edits a unique target in a 5MB UTF-8 file with exact source hash',async()=>{
+ const content=Buffer.from('a'.repeat(5*1024*1024)+'END-MARKER\n');
+ const f=fake(content),a=createCommanderWireAdapter({machineFsRuntime:f.runtime});
+ const r=await a.handlers.edit_block({file_path:'D:\\\\R139-EDIT\\\\large.log',old_string:'END-MARKER',new_string:'REPLACED',expected_replacements:1});
+ assert.equal(r.isError,undefined);
+ assert.equal(r.structuredContent.replacements,1);
+ assert.equal(f.writes(),1);
+ assert.match(f.current().subarray(-16).toString('utf8'),/REPLACED/);
+});
+test('R139 edit_block refuses invalid UTF-8 content even when the marker is ASCII',async()=>{
+ const f=fake(Buffer.concat([Buffer.from('abc TARGET'),Buffer.from([0xff,0xfe])]));
+ const a=createCommanderWireAdapter({machineFsRuntime:f.runtime});
+ await assert.rejects(a.handlers.edit_block({file_path:'D:\\\\R139-EDIT\\\\invalid.txt',old_string:'TARGET',new_string:'CHANGED',expected_replacements:1}),/invalid UTF-8|binary/);
+ assert.equal(f.writes(),0);
+});
+test('R139 edit_block preserves UTF-8 BOM when modifying existing text',async()=>{
+ const original=Buffer.concat([Buffer.from([0xef,0xbb,0xbf]),Buffer.from('header OLD tail','utf8')]);
+ const f=fake(original),a=createCommanderWireAdapter({machineFsRuntime:f.runtime});
+ await a.handlers.edit_block({file_path:'D:\\\\R139-EDIT\\\\bom.txt',old_string:'OLD',new_string:'NEW',expected_replacements:1});
+ assert.deepEqual(f.current().subarray(0,3),Buffer.from([0xef,0xbb,0xbf]));
+ assert.equal(f.current().subarray(3).toString('utf8'),'header NEW tail');
+});
+
+test('R139 text edits refuse a file above the 16MiB safety bound',async()=>{
+ const f=fake(Buffer.from('x'.repeat(17*1024*1024)+'OLD'));
+ const a=createCommanderWireAdapter({machineFsRuntime:f.runtime});
+ await assert.rejects(a.handlers.edit_block({file_path:'D:\\\\R139-EDIT\\\\too-big.log',old_string:'OLD',new_string:'NEW',expected_replacements:1}),/exceeds bounded compatibility edit limit/);
+ assert.equal(f.writes(),0);
+});

package/test/r139-large-text-read.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+
+function simulatedFile(bytes,{tamperAfter=Infinity}={}){
+ const sha=createHash('sha256').update(bytes).digest('hex');
+ let reads=0;
+ const fs={
+  policy:{roots:{core:{real_path:'D:\\\\R139-LARGE'}},max_read_bytes:1024*1024},
+  async read({offset=0,maxBytes}){
+   reads++;
+   const data=bytes.subarray(offset,offset+maxBytes);
+   return {offset,next_offset:offset+data.length,data_base64:data.toString('base64'),
+    eof:offset+data.length===bytes.length,file_size:bytes.length,
+    file_sha256:reads>=tamperAfter?'0'.repeat(64):sha};
+  }
+ };
+ return {fs,reads:()=>reads};
+}
+test('R139 reads near end of a 5MB text file in bounded native chunks without full-file buffering',async()=>{
+ const rows=Array.from({length:55000},(_,i)=>String(i).padStart(5,'0')+':'+'.'.repeat(90));
+ const source=Buffer.from(rows.join('\r\n')+'\r\n','utf8');
+ assert.ok(source.length>4*1024*1024);
+ const f=simulatedFile(source);
+ const a=createCommanderWireAdapter({machineFsRuntime:f.fs});
+ const result=await a.handlers.read_file({path:'D:\\\\R139-LARGE\\\\sample.txt',offset:54997,length:3});
+ assert.equal(result.isError,undefined,JSON.stringify(result));
+ assert.equal(result.structuredContent.lineOffset,54997);
+ assert.equal(result.structuredContent.lineCount,3);
+ assert.equal(result.structuredContent.totalLines,55001);
+ assert.equal(result.content[0].text,rows.slice(54997,55000).join('\n')+'\n');
+ assert.ok(f.reads()>4);
+});
+test('R139 detects a changing file identity during large streaming read',async()=>{
+ const source=Buffer.from(('ok-line\n').repeat(700000));
+ const f=simulatedFile(source,{tamperAfter:3});
+ const a=createCommanderWireAdapter({machineFsRuntime:f.fs});
+ await assert.rejects(a.handlers.read_file({path:'D:\\\\R139-LARGE\\\\x.log',offset:400000,length:1}),/changed during paged read|identity mismatch/);
+});
+test('R139 leaves binary compatibility handling unchanged on small files',async()=>{
+ const bytes=Buffer.from([0,2,3,4]);const f=simulatedFile(bytes);
+ const a=createCommanderWireAdapter({machineFsRuntime:f.fs});
+ const r=await a.handlers.read_file({path:'D:\\\\R139-LARGE\\\\x.bin',offset:0,length:5});
+ assert.equal(r.structuredContent.isBinary,true);
+});