deadbyte-mcp 0.15.18 → 0.15.19

package/test/commander-office-reader-r48.test.mjs

@@ -0,0 +1,152 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from '../src/commander-office-reader-r48.mjs';
+
+function crc32(buf){
+  let c=0xffffffff;
+  for(const b of buf){c^=b;for(let k=0;k<8;k++)c=(c>>>1)^((c&1)?0xedb88320:0);}
+  return (c^0xffffffff)>>>0;
+}
+function zipStored(entries){
+  const locals=[],centrals=[]; let offset=0;
+  for(const [name,value] of Object.entries(entries)){
+    const n=Buffer.from(name,'utf8'),data=Buffer.from(value,'utf8'),crc=crc32(data);
+    const local=Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50,0);local.writeUInt16LE(20,4);local.writeUInt16LE(0x800,6);local.writeUInt16LE(0,8);
+    local.writeUInt32LE(crc,14);local.writeUInt32LE(data.length,18);local.writeUInt32LE(data.length,22);local.writeUInt16LE(n.length,26);
+    locals.push(local,n,data);
+    const central=Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50,0);central.writeUInt16LE(20,4);central.writeUInt16LE(20,6);central.writeUInt16LE(0x800,8);central.writeUInt16LE(0,10);
+    central.writeUInt32LE(crc,16);central.writeUInt32LE(data.length,20);central.writeUInt32LE(data.length,24);central.writeUInt16LE(n.length,28);central.writeUInt32LE(offset,42);
+    centrals.push(central,n);
+    offset+=local.length+n.length+data.length;
+  }
+  const centralBytes=Buffer.concat(centrals),localBytes=Buffer.concat(locals);
+  const eocd=Buffer.alloc(22);
+  eocd.writeUInt32LE(0x06054b50,0);eocd.writeUInt16LE(Object.keys(entries).length,8);eocd.writeUInt16LE(Object.keys(entries).length,10);
+  eocd.writeUInt32LE(centralBytes.length,12);eocd.writeUInt32LE(localBytes.length,16);
+  return Buffer.concat([localBytes,centralBytes,eocd]);
+}
+
+const DOCX=zipStored({
+  'word/document.xml':'<?xml version="1.0"?><w:document xmlns:w="x"><w:body><w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>Hello &amp; world</w:t></w:r></w:p><w:p><w:r><w:t>Second</w:t></w:r><w:tab/><w:r><w:t>line</w:t></w:r></w:p><w:tbl><w:tr><w:tc><w:p><w:r><w:t>A</w:t></w:r></w:p></w:tc><w:tc><w:p><w:r><w:t>B</w:t></w:r></w:p></w:tc></w:tr></w:tbl></w:body></w:document>'
+});
+
+const XLSX=zipStored({
+  'xl/workbook.xml':'<workbook xmlns:r="r"><sheets><sheet name="Data" sheetId="1" r:id="rId1"/></sheets></workbook>',
+  'xl/_rels/workbook.xml.rels':'<Relationships><Relationship Id="rId1" Target="worksheets/sheet1.xml"/></Relationships>',
+  'xl/sharedStrings.xml':'<sst><si><t>Name</t></si><si><t>Alpha</t></si><si><t>Beta</t></si></sst>',
+  'xl/worksheets/sheet1.xml':'<worksheet><sheetData><row r="1"><c r="A1" t="s"><v>0</v></c><c r="B1" t="inlineStr"><is><t>Count</t></is></c></row><row r="2"><c r="A2" t="s"><v>1</v></c><c r="B2"><v>42</v></c></row><row r="3"><c r="A3" t="s"><v>2</v></c><c r="B3" t="b"><v>1</v></c></row></sheetData></worksheet>'
+});
+
+test('R48 native DOCX reader produces text-bearing outline and paged raw XML',()=>{
+  const outline=readDocxBytes(DOCX,{path:'demo.docx',offset:0,length:1000});
+  assert.equal(outline.mimeType,'text/plain');
+  assert.match(outline.content,/\[0\] w:p style="Heading1"/);
+  assert.match(outline.content,/Hello & world/);
+  assert.match(outline.content,/Second\tline/);
+  assert.match(outline.content,/w:tbl/);
+  assert.match(outline.content,/A \| B/);
+  const raw=readDocxBytes(DOCX,{path:'demo.docx',offset:1,length:3});
+  assert.equal(raw.mimeType,'application/xml');
+  assert.match(raw.content,/\[DOCX XML: lines 1-/);
+  assert.equal(raw.metadata.isDocx,true);
+});
+
+test('R48 native XLSX reader preserves types, sheet selection, A1 range, and row pagination',()=>{
+  const range=readXlsxBytes(XLSX,{path:'book.xlsx',sheet:'Data',range:'A1:B2',offset:0,length:100});
+  assert.deepEqual(range.data,[['Name','Count'],['Alpha',42]]);
+  assert.equal(range.sheetName,'Data');
+  assert.equal(range.mimeType,'application/json');
+  assert.deepEqual(range.metadata.sheets.map(s=>s.name),['Data']);
+  const page=readXlsxBytes(XLSX,{path:'book.xlsx',sheet:'Data',offset:1,length:1});
+  assert.deepEqual(page.data,[['Alpha',42]]);
+  const embedded=readXlsxBytes(XLSX,{path:'book.xlsx',range:"'Data'!A2:B3",offset:0,length:100});
+  assert.deepEqual(embedded.data,[['Alpha',42],['Beta',true]]);
+});
+
+test('R48 office ZIP parser rejects traversal and CRC corruption',()=>{
+  const evil=zipStored({'../word/document.xml':'x'});
+  assert.throws(()=>readDocxBytes(evil,{path:'evil.docx'}),/unsafe ZIP entry/);
+  const corrupt=Buffer.from(DOCX);
+  const marker=Buffer.from('Hello &amp; world');
+  const at=corrupt.indexOf(marker);
+  assert.ok(at>0); corrupt[at]^=1;
+  assert.throws(()=>readDocxBytes(corrupt,{path:'corrupt.docx'}),/CRC32 mismatch/);
+});
+
+test('R48 native XLSX range editor rewrites existing cells and creates missing rows/cells without shared-string mutation',()=>{
+  const edited=editXlsxBytes(XLSX,{
+    range:"'Data'!A2:C4",
+    content:[
+      ['Gamma',7,true],
+      ['Delta',8,false],
+      ['New',9,null]
+    ]
+  });
+  const read=readXlsxBytes(edited.bytes,{path:'book.xlsx',sheet:'Data',range:'A1:C4',offset:0,length:100});
+  assert.deepEqual(read.data,[
+    ['Name','Count',null],
+    ['Gamma',7,true],
+    ['Delta',8,false],
+    ['New',9,null]
+  ]);
+  assert.match(edited.before_sha256,/^[0-9a-f]{64}$/);
+  assert.match(edited.after_sha256,/^[0-9a-f]{64}$/);
+  assert.notEqual(edited.before_sha256,edited.after_sha256);
+  assert.equal(edited.updated_cells,9);
+});
+
+test('R48 native XLSX range editor fails closed on shape mismatch and unsupported value type',()=>{
+  assert.throws(()=>editXlsxBytes(XLSX,{range:'Data!A1:B2',content:[[1,2],[3]]}),/shape mismatch/);
+  assert.throws(()=>editXlsxBytes(XLSX,{range:'Data!A1',content:[[{}]]}),/unsupported XLSX cell value/);
+});
+
+test('R48 native XLSX creator emits deterministic multi-sheet OOXML readable by the same parser',()=>{
+  const made=createXlsxBytes({
+    Sheet1:[['Name','Count'],['Alpha',1]],
+    Data:[['Flag','Value'],[true,2]]
+  });
+  const s1=readXlsxBytes(made.bytes,{path:'new.xlsx',sheet:'Sheet1',range:'A1:B2'});
+  const data=readXlsxBytes(made.bytes,{path:'new.xlsx',sheet:'Data',range:'A1:B2'});
+  assert.deepEqual(s1.data,[['Name','Count'],['Alpha',1]]);
+  assert.deepEqual(data.data,[['Flag','Value'],[true,2]]);
+  assert.match(made.bytes_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(made.sheet_count,2);
+  const again=createXlsxBytes({Sheet1:[['Name','Count'],['Alpha',1]],Data:[['Flag','Value'],[true,2]]});
+  assert.equal(again.bytes_sha256,made.bytes_sha256);
+});
+
+test('R48 native XLSX append preserves existing package and appends rows to an existing sheet',()=>{
+  const base=createXlsxBytes({Sheet1:[['A',1],['B',2]]});
+  const appended=appendXlsxBytes(base.bytes,{Sheet1:[['C',3],['D',4]]});
+  const read=readXlsxBytes(appended.bytes,{path:'append.xlsx',sheet:'Sheet1',range:'A1:B4'});
+  assert.deepEqual(read.data,[['A',1],['B',2],['C',3],['D',4]]);
+  assert.equal(appended.appended_rows,2);
+  assert.throws(()=>appendXlsxBytes(base.bytes,{Missing:[[1]]}),/Sheet "Missing" not found/);
+});
+
+test('R48 native XLSX creator rejects unsafe sheet names and non-rectangular data',()=>{
+  assert.throws(()=>createXlsxBytes({'bad/name':[[1]]}),/sheet name invalid/);
+  assert.throws(()=>createXlsxBytes({Sheet1:[[1,2],[3]]}),/rectangular/);
+});
+
+test('R48 native DOCX editor performs exact pretty-XML replacement and repacks a valid document',()=>{
+  const raw=readDocxBytes(DOCX,{path:'demo.docx',offset:1,length:200});
+  assert.match(raw.content,/Hello &amp; world/);
+  const edited=editDocxBytes(DOCX,{
+    oldString:'<w:t>Hello &amp; world</w:t>',
+    newString:'<w:t>Hello DEADBYTE</w:t>',
+    expectedReplacements:1
+  });
+  const read=readDocxBytes(edited.bytes,{path:'demo.docx',offset:0,length:1000});
+  assert.match(read.content,/Hello DEADBYTE/);
+  assert.doesNotMatch(read.content,/Hello & world/);
+  assert.equal(edited.replacements,1);
+  assert.match(edited.before_sha256,/^[0-9a-f]{64}$/);
+  assert.match(edited.after_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('R48 native DOCX editor refuses ambiguous replacement counts before repack',()=>{
+  assert.throws(()=>editDocxBytes(DOCX,{oldString:'<w:p>',newString:'<w:p>',expectedReplacements:1}),/expected 1 replacements/);
+});

package/test/commander-pdf-r48.test.mjs

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+import { createDeadbytePdf, parseDeadbytePdf, editDeadbytePdf, readPdfText } from '../src/commander-pdf-r48.mjs';
+
+test('R48 ordinary PDF with compressed object streams preserves pages through independent oracle reload',async()=>{
+  const oracle=process.env.DEADBYTE_PDF_TEST_ORACLE??path.join(os.homedir(),'.deadbyte-mcp','evidence','commander-oracle','node_modules','pdf-lib','cjs','index.js');
+  const {PDFDocument}=await import(pathToFileURL(oracle).href);
+  const reference=await PDFDocument.create();
+  reference.addPage([321,456]);reference.addPage([654,789]);
+  const fixture=await reference.save({useObjectStreams:true});
+  const edited=await editDeadbytePdf(fixture,[{type:'delete',pageIndexes:[0]}]);
+  const reloaded=await PDFDocument.load(edited.bytes);
+  assert.equal(reloaded.getPageCount(),1);
+  assert.equal(reloaded.getPage(0).getWidth(),654);
+  assert.equal(reloaded.getPage(0).getHeight(),789);
+});
+
+test('R48 compressed object streams reject duplicate identity and malformed indexes before mutation',async()=>{
+  const {deflateSync}=await import('node:zlib');
+  const make=(index,body,n,first)=>{
+    const stream=deflateSync(Buffer.from(index+body,'latin1'));
+    return Buffer.concat([Buffer.from(`%PDF-1.5\n1 0 obj << /Type /ObjStm /N ${n} /First ${first} /Filter /FlateDecode /Length ${stream.length} >>\nstream\n`),stream,Buffer.from('\nendstream\nendobj\n%%EOF')]);
+  };
+  assert.throws(()=>readPdfText(make('1 0 ','<< /Type /Catalog >>',1,4)),/duplicate object/);
+  assert.throws(()=>readPdfText(make('2 999 ','<< /Type /Catalog >>',1,6)),/entry invalid/);
+  assert.throws(()=>readPdfText(make('2 0 ','<< /Type /Catalog >>',2,4)),/count mismatch/);
+});
+
+test('R48 native PDF profile round-trips exact page text and exposes stable page count',()=>{
+  const made=createDeadbytePdf(['alpha','beta\ngamma']);
+  assert.equal(made.mime_type,'application/pdf');
+  assert.match(made.bytes.subarray(0,64).toString('ascii'),/%PDF-1\.4/);
+  const parsed=parseDeadbytePdf(made.bytes);
+  assert.deepEqual(parsed.pages,['alpha','beta\ngamma']);
+  assert.equal(parsed.page_count,2);
+  assert.equal(parsed.profile,'deadbyte-pdf-r48');
+});
+
+test('R48 PDF delete uses Desktop Commander negative-index semantics without page confusion',async()=>{
+  const base=createDeadbytePdf(['p0','p1','p2']).bytes;
+  const edited=await editDeadbytePdf(base,[{type:'delete',pageIndexes:[-1,99,-3,-3]}]);
+  assert.deepEqual(parseDeadbytePdf(edited.bytes).pages,['p1']);
+});
+
+test('R48 PDF insert supports markdown and source PDF pages with exact ordered insertion',async()=>{
+  const base=createDeadbytePdf(['A','D']).bytes;
+  const source=createDeadbytePdf(['B','C']).bytes;
+  const edited=await editDeadbytePdf(base,[
+    {type:'insert',pageIndex:1,markdown:'X'},
+    {type:'insert',pageIndex:2,sourcePdfPath:'source.pdf'}
+  ],{
+    sourceResolver:async path=>{
+      assert.equal(path,'source.pdf');
+      return source;
+    }
+  });
+  assert.deepEqual(parseDeadbytePdf(edited.bytes).pages,['A','X','B','C','D']);
+});
+
+test('R48 ordinary classic PDF surgery preserves selected content graphs and supports inserts',async()=>{
+  const ordinary=Buffer.from(createDeadbytePdf(['A','B']).bytes.toString('latin1').replace('%DEADBYTE-PDF-R48','%ORDINARY-PDF-R48 '),'latin1');
+  const source=Buffer.from(createDeadbytePdf(['C']).bytes.toString('latin1').replace('%DEADBYTE-PDF-R48','%ORDINARY-PDF-R48 '),'latin1');
+  const edited=await editDeadbytePdf(ordinary,[
+    {type:'delete',pageIndexes:[0]},
+    {type:'insert',pageIndex:1,markdown:'X'},
+    {type:'insert',pageIndex:2,sourcePdfPath:'source.pdf'}
+  ],{sourceResolver:async()=>source});
+  const read=readPdfText(edited.bytes);
+  assert.equal(read.profile,'generic-pdf-r48');
+  assert.equal(read.page_count,3);
+  assert.deepEqual(read.pages,['B','X','C']);
+});
+
+test('R48 generic PDF reader extracts bounded text from classic plain content streams',()=>{
+  const pdf=Buffer.from('%PDF-1.4\n1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n3 0 obj\n<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>\nendobj\n4 0 obj\n<< /Length 74 >>\nstream\nBT /F1 12 Tf 72 720 Td (Hello\\040foreign) Tj 0 -14 Td (page one) Tj ET\nendstream\nendobj\n%%EOF\n','latin1');
+  const parsed=readPdfText(pdf);
+  assert.equal(parsed.profile,'generic-pdf-r48');
+  assert.equal(parsed.page_count,1);
+  assert.match(parsed.pages[0],/Hello foreign/);
+  assert.match(parsed.pages[0],/page one/);
+  assert.equal(parsed.partial,false);
+});
+
+test('R48 generic PDF reader inflates Flate streams and extracts TJ plus hex strings',async()=>{
+  const {deflateSync}=await import('node:zlib');
+  const raw='BT /F1 12 Tf 72 720 Td [(Second) 120 ( page)] TJ T* <7468726565> Tj ET';
+  const compressed=deflateSync(Buffer.from(raw,'latin1'));
+  const head=Buffer.from(`%PDF-1.4\n1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n3 0 obj\n<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>\nendobj\n4 0 obj\n<< /Filter /FlateDecode /Length ${compressed.length} >>\nstream\n`,'latin1');
+  const tail=Buffer.from('\nendstream\nendobj\n%%EOF\n','latin1');
+  const parsed=readPdfText(Buffer.concat([head,compressed,tail]));
+  assert.equal(parsed.page_count,1);
+  assert.match(parsed.pages[0],/Second page/);
+  assert.match(parsed.pages[0],/three/);
+  assert.equal(parsed.partial,false);
+});
+
+test('R48 generic PDF reader fails closed when page content uses an unsupported filter',()=>{
+  const pdf=Buffer.from('%PDF-1.4\n1 0 obj\n<< /Type /Page /Contents 2 0 R >>\nendobj\n2 0 obj\n<< /Filter /LZWDecode >>\nstream\nabc\nendstream\nendobj\n%%EOF\n','latin1');
+  assert.throws(()=>readPdfText(pdf),/unsupported PDF stream filter/);
+});

package/test/commander-protocol-r47.test.mjs

@@ -18,7 +18,10 @@ const execFileAsync=promisify(execFile);
 async function materializeTestHostPolicy(root){
   const policyPath=path.join(root,'deadbyte-host-policy.json');
   const script=path.join(repoRoot,'scripts','init-host-policy.ps1');
-  await execFileAsync('powershell.exe',['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',script,'-CoreRoot',repoRoot,'-BridgeRoot',repoRoot,'-PolicyPath',policyPath],{windowsHide:true});
+  // Windows PowerShell must derive its own module path, not inherit incompatible
+  // PowerShell 7 modules from the verifier's parent process.
+  const env={...process.env};delete env.PSModulePath;
+  await execFileAsync('powershell.exe',['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',script,'-CoreRoot',repoRoot,'-BridgeRoot',repoRoot,'-PolicyPath',policyPath],{windowsHide:true,env});
   return policyPath;
 }
 
@@ -41,5 +44,24 @@ test('Commander R47 exact 40-name surface is registered over real MCP stdio',asy
     for(const name of expected) assert.ok(names.includes(name),'missing tool: '+name);
     assert.equal(new Set(expected).size,40);
     for(const name of expected){const t=listed.tools.find(x=>x.name===name);assert.ok(t.inputSchema,'missing schema: '+name);}
+    assert.equal(names.includes('track_ui_event'),false,'hidden UI dispatch must not be advertised');
+    const hidden=await client.callTool({name:'track_ui_event',arguments:{event:'preview_opened',component:'file_preview',params:{kind:'docx'}}});
+    assert.equal(hidden.isError,undefined,JSON.stringify(hidden));
+    assert.equal(hidden.structuredContent?.accepted,true);
+    const resources=await client.listResources();
+    assert.ok(resources.resources.some(resource=>resource.uri==='deadbyte://context'));
+    for(const uri of ['ui://desktop-commander/file-preview','ui://desktop-commander/config-editor']){
+      assert.ok(resources.resources.some(resource=>resource.uri===uri),`missing reference UI resource ${uri}`);
+      const response=await client.readResource({uri});
+      assert.equal(response.contents[0].mimeType,'text/html;profile=mcp-app');
+      assert.ok(response.contents[0].text.length<65536);
+      assert.match(response.contents[0].text,/Content-Security-Policy/);
+      assert.doesNotMatch(response.contents[0].text,/<script[^>]+src=|https?:\/\//);
+    }
+    const context=await client.readResource({uri:'deadbyte://context'});
+    assert.equal(context.contents[0].mimeType,'text/markdown');
+    assert.ok(context.contents[0].text.length>0&&context.contents[0].text.length<1024*1024);
+    const templates=await client.listResourceTemplates();
+    assert.deepEqual(templates.resourceTemplates,[]);
   }finally{await client.close().catch(()=>{});await rm(root,{recursive:true,force:true}).catch(()=>{});}
 });

package/test/commander-reference-contract-r48.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import * as compat from '../src/commander-compat-contracts.mjs';
+
+const expectedPublic=Object.freeze([
+  'get_config','set_config_value','read_file','read_multiple_files','write_file','write_pdf',
+  'create_directory','list_directory','move_file','start_search','get_more_search_results',
+  'stop_search','list_searches','get_file_info','edit_block','start_process',
+  'read_process_output','interact_with_process','force_terminate','list_sessions',
+  'list_processes','kill_process','get_usage_stats','get_recent_tool_calls',
+  'give_feedback_to_desktop_commander','get_prompts'
+].sort());
+
+test('R48 pins Desktop Commander 0.2.51 advertised public wire separately from DEADBYTE additive tools',async()=>{
+  assert.ok(Array.isArray(compat.COMMANDER_REFERENCE_PUBLIC_TOOLS),'reference public tool contract missing');
+  assert.deepEqual([...compat.COMMANDER_REFERENCE_PUBLIC_TOOLS].sort(),expectedPublic);
+  assert.ok(compat.COMMANDER_COMPAT_TOOLS.length>compat.COMMANDER_REFERENCE_PUBLIC_TOOLS.length);
+  const doc=JSON.parse(await readFile(new URL('../docs/COMMANDER_EXHAUSTIVE_SURFACE.json',import.meta.url),'utf8'));
+  assert.equal(doc.reference.server_sha256,'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
+  assert.equal(doc.reference.schemas_sha256,'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
+  assert.deepEqual([...doc.reference_public_surface].sort(),expectedPublic);
+  assert.equal(doc.reference_hidden_dispatch.includes('track_ui_event'),true);
+  assert.equal(doc.status_counts.reference_public,26);
+  assert.equal(doc.status_counts.deadbyte_additive,doc.surface.length-26);
+});

package/test/commander-schema-differential-r48.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
+
+const referencePath='D:\\Projects\\deadbyte-mcp\\desktop-commander\\dist\\tools\\schemas.js';
+const expectedHash='f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140';
+async function referenceSchemas(){
+  let source=await readFile(referencePath,'utf8');
+  assert.equal(createHash('sha256').update(source).digest('hex'),expectedHash);
+  const zodUrl=new URL('../node_modules/zod/v3/index.js',import.meta.url).href;
+  source=source.replace('from "zod"',`from ${JSON.stringify(zodUrl)}`);
+  return (await import(`data:text/javascript;base64,${Buffer.from(source).toString('base64')}`)).toolArgSchemas;
+}
+function candidateSchemas(){
+  const schemas={...createCommanderWireAdapter({}).schemas};
+  registerCommanderExtendedBridge({registerTool(name,definition){schemas[name]=definition.inputSchema;}},{extendedRuntime:{}});
+  return schemas;
+}
+const valid={
+  get_config:{},set_config_value:{key:'k',value:'v'},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'}
+};
+
+function objectShape(schema){
+  while(schema._def?.schema)schema=schema._def.schema;
+  return schema.shape;
+}
+
+test('R48 exhaustive public property and required/default semantics match the pinned reference',async()=>{
+  const reference=await referenceSchemas(),candidate=candidateSchemas();
+  const values=[undefined,null,false,true,-1,0,1,1.5,1000,1001,'','x','ui','llm','files','content','rewrite','append','get_prompt','2026-09-27T00:00:00Z','bad',[],['x'],[1],{}, {x:1}];
+  for(const [name,base] of Object.entries(valid)){
+    const expectedKeys=Object.keys(objectShape(reference[name])).sort();
+    const actualKeys=Object.keys(objectShape(candidate[name])).sort();
+    assert.deepEqual(actualKeys,expectedKeys,`${name} public properties`);
+    const compare=input=>{
+      const expected=reference[name].safeParse(input),actual=candidate[name].safeParse(input);
+      assert.equal(actual.success,expected.success,`${name} ${JSON.stringify(input)} acceptance`);
+      if(actual.success)assert.deepEqual(actual.data,expected.data,`${name} ${JSON.stringify(input)} defaults/normalization`);
+    };
+    for(const field of expectedKeys){
+      const absent={...base};delete absent[field];compare(absent);
+      for(const value of values)compare({...base,[field]:value});
+    }
+  }
+});
+
+test('R48 all 26 advertised schemas accept, normalize defaults, and strip unknown keys like pinned reference',async()=>{
+  const reference=await referenceSchemas(),candidate=candidateSchemas();
+  assert.deepEqual(Object.keys(valid).sort(),Object.keys(reference).filter(name=>name!=='track_ui_event').sort());
+  for(const [name,input] of Object.entries(valid)){
+    assert.ok(candidate[name],`candidate schema missing ${name}`);
+    const withUnknown={...input,__reference_unknown:'strip-me'};
+    const expected=reference[name].safeParse(withUnknown),actual=candidate[name].safeParse(withUnknown);
+    assert.equal(actual.success,expected.success,`${name} acceptance mismatch`);
+    assert.deepEqual(actual.success?actual.data:null,expected.success?expected.data:null,`${name} normalized value mismatch`);
+  }
+});
+
+test('R48 material enum union refinement and constraint probes match pinned reference schemas',async()=>{
+  const reference=await referenceSchemas(),candidate=candidateSchemas();
+  const probes={
+    get_config:[{origin:'bad'}],set_config_value:[{key:'k',value:{bad:true}}],read_file:[{path:'x',isUrl:'yes'}],
+    read_multiple_files:[{paths:[1]}],write_file:[{path:'x',content:'x',mode:'bad'}],
+    write_pdf:[{path:'x',content:'[{"type":"delete","pageIndexes":[0]}]'},{path:'x',content:'[{"type":"bad"}]'}],
+    create_directory:[{}],list_directory:[{path:'x',origin:'bad'}],move_file:[{source:'a'}],
+    start_search:[{path:'.',pattern:'x',searchType:'bad'}],get_more_search_results:[{sessionId:1}],
+    stop_search:[{}],list_searches:[1],get_file_info:[{}],edit_block:[{file_path:'x'}],
+    start_process:[{command:'x'}],read_process_output:[{pid:'1'}],interact_with_process:[{pid:1}],
+    force_terminate:[{}],list_sessions:[1],list_processes:[1],kill_process:[{pid:'1'}],get_usage_stats:[1],
+    get_recent_tool_calls:[{maxResults:0},{maxResults:1.5},{since:'bad'}],give_feedback_to_desktop_commander:[1],
+    get_prompts:[{action:'bad',promptId:'x'}]
+  };
+  for(const [name,inputs] of Object.entries(probes)) for(const input of inputs){
+    const expected=reference[name].safeParse(input),actual=candidate[name].safeParse(input);
+    assert.equal(actual.success,expected.success,`${name} mismatch for ${JSON.stringify(input)}`);
+    if(actual.success)assert.deepEqual(actual.data,expected.data,`${name} normalized mismatch`);
+  }
+});

package/test/commander-url-reader-r48.test.mjs

@@ -0,0 +1,68 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createCommanderUrlReader, isPublicInternetAddress } from '../src/commander-url-reader-r48.mjs';
+
+test('R48 URL reader classifies public vs local/reserved addresses conservatively',()=>{
+  for(const ip of ['127.0.0.1','10.0.0.1','172.16.0.1','192.168.1.1','169.254.1.1','100.64.0.1','0.0.0.0','224.0.0.1','::1','fe80::1','fc00::1','2001:db8::1']) {
+    assert.equal(isPublicInternetAddress(ip),false,ip);
+  }
+  for(const ip of ['8.8.8.8','1.1.1.1','2606:4700:4700::1111']) {
+    assert.equal(isPublicInternetAddress(ip),true,ip);
+  }
+});
+
+test('R48 URL reader rejects private DNS answers before network transport',async()=>{
+  let requests=0;
+  const reader=createCommanderUrlReader({
+    lookupFn:async()=>[{address:'127.0.0.1',family:4}],
+    requestOnceFn:async()=>{requests++;return {status:200,headers:{'content-type':'text/plain'},body:Buffer.from('no')};}
+  });
+  await assert.rejects(reader('https://example.test/a'),/non-public address/);
+  assert.equal(requests,0);
+});
+
+test('R48 URL reader revalidates every redirect and returns bounded text',async()=>{
+  const lookups=[];
+  const requests=[];
+  const reader=createCommanderUrlReader({
+    lookupFn:async host=>{
+      lookups.push(host);
+      return [{address:host==='first.example'?'8.8.8.8':'1.1.1.1',family:4}];
+    },
+    requestOnceFn:async({url,address})=>{
+      requests.push({url:url.href,address:address.address});
+      if(url.hostname==='first.example') return {status:302,headers:{location:'https://second.example/final'},body:Buffer.alloc(0)};
+      return {status:200,headers:{'content-type':'text/plain; charset=utf-8'},body:Buffer.from('alpha\nbeta\n','utf8')};
+    }
+  });
+  const result=await reader('https://first.example/start');
+  assert.deepEqual(lookups,['first.example','second.example']);
+  assert.deepEqual(requests.map(x=>x.address),['8.8.8.8','1.1.1.1']);
+  assert.equal(result.content,'alpha\nbeta\n');
+  assert.equal(result.mimeType,'text/plain');
+  assert.equal(result.isImage,false);
+  assert.match(result.sha256,/^[0-9a-f]{64}$/);
+});
+
+test('R48 URL reader rejects oversized body even when transport returns success',async()=>{
+  const reader=createCommanderUrlReader({
+    maxBytes:16,
+    lookupFn:async()=>[{address:'8.8.8.8',family:4}],
+    requestOnceFn:async()=>({status:200,headers:{'content-type':'text/plain'},body:Buffer.alloc(17)})
+  });
+  await assert.rejects(reader('https://example.test/a'),/byte limit/);
+});
+
+test('R48 URL reader returns bounded PDF bytes for the native document adapter',async()=>{
+  const body=Buffer.from('%PDF-1.4\n%fixture\n','ascii');
+  const reader=createCommanderUrlReader({
+    lookupFn:async()=>[{address:'8.8.8.8',family:4}],
+    requestOnceFn:async()=>({status:200,headers:{'content-type':'application/pdf'},body})
+  });
+  const result=await reader('https://example.test/a.pdf');
+  assert.equal(result.isPdf,true);
+  assert.equal(result.isImage,false);
+  assert.equal(result.mimeType,'application/pdf');
+  assert.equal(Buffer.from(result.content,'base64').equals(body),true);
+  assert.match(result.sha256,/^[0-9a-f]{64}$/);
+});