deadbyte-mcp 0.15.18 → 0.15.19

package/src/commander-pdf-r48.mjs

@@ -0,0 +1,448 @@
+import { createHash } from 'node:crypto';
+import { inflateSync } from 'node:zlib';
+
+const PROFILE_MARKER='%DEADBYTE-PDF-R48';
+const MAX_PAGES=512;
+const MAX_FILE_BYTES=64*1024*1024;
+const MAX_PAGE_TEXT_BYTES=1024*1024;
+const UTF8=new TextDecoder('utf-8',{fatal:true});
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+function assertPageText(value,index){
+  if(typeof value!=='string') throw new Error(`PDF page ${index} text must be string`);
+  if(Buffer.byteLength(value,'utf8')>MAX_PAGE_TEXT_BYTES) throw new Error(`PDF page ${index} text exceeds byte limit`);
+}
+function renderableByte(ch){
+  const cp=ch.codePointAt(0);
+  if(cp===9) return '    ';
+  if(cp>=32&&cp<=126) return ch;
+  if(cp>=160&&cp<=255) return ch;
+  if(cp===10||cp===13) return '';
+  return '?';
+}
+function pdfEscape(text){
+  let out='';
+  for(const ch of text) out+=renderableByte(ch).replaceAll('\\','\\\\').replaceAll('(','\\(').replaceAll(')','\\)');
+  return out;
+}
+function renderPage(text){
+  const lines=String(text).replaceAll('\r\n','\n').replaceAll('\r','\n').split('\n').slice(0,2000);
+  const out=['BT','/F1 11 Tf','50 742 Td','14 TL'];
+  for(const line of lines){
+    out.push(`(${pdfEscape(line).slice(0,4096)}) Tj`);
+    out.push('0 -14 Td');
+  }
+  out.push('ET');
+  return out.join('\n');
+}
+function utf8Hex(text){return Buffer.from(text,'utf8').toString('hex').toUpperCase();}
+function decodeHexUtf8(hex){
+  if(typeof hex!=='string'||hex.length%2!==0||!/^[0-9A-Fa-f]*$/.test(hex)) throw new Error('PDF DBText hex invalid');
+  try{return UTF8.decode(Buffer.from(hex,'hex'));}catch{throw new Error('PDF DBText is not valid UTF-8');}
+}
+
+export function createDeadbytePdf(pages,{metadata={}}={}){
+  if(!Array.isArray(pages)) throw new Error('PDF pages must be array');
+  if(pages.length>MAX_PAGES) throw new Error(`PDF page count exceeds ${MAX_PAGES}`);
+  pages.forEach(assertPageText);
+  const nl='\n';
+  const fontId=3;
+  const pageId=i=>4+i*2;
+  const contentId=i=>5+i*2;
+  const kids=pages.map((_,i)=>`${pageId(i)} 0 R`).join(' ');
+  const objects=new Map();
+  objects.set(1,'<< /Type /Catalog /Pages 2 0 R >>');
+  objects.set(2,`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>`);
+  objects.set(3,'<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>');
+  for(let i=0;i<pages.length;i++){
+    const stream=renderPage(pages[i]);
+    objects.set(pageId(i),`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 ${fontId} 0 R >> >> /Contents ${contentId(i)} 0 R /DBPageIndex ${i} /DBText <${utf8Hex(pages[i])}> >>`);
+    objects.set(contentId(i),`<< /Length ${Buffer.byteLength(stream,'latin1')} >>${nl}stream${nl}${stream}${nl}endstream`);
+  }
+  const maxId=3+pages.length*2;
+  let out=`%PDF-1.4${nl}${PROFILE_MARKER}${nl}`;
+  const offsets=new Array(maxId+1).fill(0);
+  for(let id=1;id<=maxId;id++){
+    const body=objects.get(id);
+    if(body===undefined) throw new Error(`PDF object ${id} missing`);
+    offsets[id]=Buffer.byteLength(out,'latin1');
+    out+=`${id} 0 obj${nl}${body}${nl}endobj${nl}`;
+  }
+  const xref=Buffer.byteLength(out,'latin1');
+  out+=`xref${nl}0 ${maxId+1}${nl}0000000000 65535 f ${nl}`;
+  for(let id=1;id<=maxId;id++) out+=`${String(offsets[id]).padStart(10,'0')} 00000 n ${nl}`;
+  out+=`trailer${nl}<< /Size ${maxId+1} /Root 1 0 R >>${nl}startxref${nl}${xref}${nl}%%EOF${nl}`;
+  const bytes=Buffer.from(out,'latin1');
+  if(bytes.length>MAX_FILE_BYTES) throw new Error('PDF output exceeds byte limit');
+  return {profile:'deadbyte-pdf-r48',mime_type:'application/pdf',page_count:pages.length,bytes,bytes_base64:bytes.toString('base64'),bytes_sha256:sha256(bytes),metadata};
+}
+
+export function parseDeadbytePdf(input){
+  const bytes=Buffer.isBuffer(input)?input:Buffer.from(input);
+  if(bytes.length>MAX_FILE_BYTES) throw new Error('PDF input exceeds byte limit');
+  const head=bytes.subarray(0,256).toString('latin1');
+  if(!head.startsWith('%PDF-')||!head.includes(PROFILE_MARKER)) throw new Error('unsupported PDF profile: expected DEADBYTE-PDF-R48');
+  const text=bytes.toString('latin1');
+  const pages=[];
+  const re=/(\d+)\s+0\s+obj\s*([\s\S]*?)\s*endobj/g;
+  let m;
+  while((m=re.exec(text))){
+    const body=m[2];
+    if(!/\/Type\s*\/Page\b/.test(body)||/\/Type\s*\/Pages\b/.test(body)) continue;
+    const indexRaw=body.match(/\/DBPageIndex\s+(\d+)/)?.[1];
+    const hex=body.match(/\/DBText\s*<([0-9A-Fa-f]*)>/)?.[1];
+    if(indexRaw===undefined||hex===undefined) throw new Error('unsupported PDF profile: page metadata missing');
+    const index=Number(indexRaw);
+    if(!Number.isInteger(index)||index<0||index>=MAX_PAGES) throw new Error('PDF page index invalid');
+    if(pages[index]!==undefined) throw new Error('PDF page index duplicate');
+    pages[index]=decodeHexUtf8(hex);
+  }
+  const countRaw=text.match(/\/Type\s*\/Pages\b[\s\S]*?\/Count\s+(\d+)/)?.[1];
+  if(countRaw===undefined) throw new Error('unsupported PDF profile: Pages count missing');
+  const count=Number(countRaw);
+  if(!Number.isInteger(count)||count<0||count>MAX_PAGES) throw new Error('PDF page count invalid');
+  if(pages.length!==count||pages.some(x=>x===undefined)) throw new Error('unsupported PDF profile: page index set incomplete');
+  return {profile:'deadbyte-pdf-r48',page_count:count,pages};
+}
+
+
+const MAX_GENERIC_OBJECTS=10000;
+const MAX_GENERIC_STREAM_BYTES=16*1024*1024;
+
+function decodePdfTextBytes(bytes){
+  if(bytes.length>=2&&bytes[0]===0xfe&&bytes[1]===0xff){
+    let out='';
+    for(let i=2;i+1<bytes.length;i+=2) out+=String.fromCharCode((bytes[i]<<8)|bytes[i+1]);
+    return out;
+  }
+  if(bytes.length>=2&&bytes[0]===0xff&&bytes[1]===0xfe){
+    return bytes.subarray(2).toString('utf16le');
+  }
+  return bytes.toString('latin1');
+}
+function decodePdfLiteralToken(token){
+  if(!token.startsWith('(')||!token.endsWith(')')) throw new Error('PDF literal token invalid');
+  const src=token.slice(1,-1),out=[];
+  for(let i=0;i<src.length;i++){
+    const code=src.charCodeAt(i)&0xff;
+    if(code!==0x5c){out.push(code);continue;}
+    if(++i>=src.length) break;
+    const ch=src[i];
+    const simple={n:0x0a,r:0x0d,t:0x09,b:0x08,f:0x0c,'(':0x28,')':0x29,'\\':0x5c}[ch];
+    if(simple!==undefined){out.push(simple);continue;}
+    if(ch==='\r'||ch==='\n'){
+      if(ch==='\r'&&src[i+1]==='\n') i++;
+      continue;
+    }
+    if(/[0-7]/.test(ch)){
+      let oct=ch;
+      for(let k=0;k<2&&i+1<src.length&&/[0-7]/.test(src[i+1]);k++) oct+=src[++i];
+      out.push(parseInt(oct,8)&0xff);continue;
+    }
+    out.push(ch.charCodeAt(0)&0xff);
+  }
+  return decodePdfTextBytes(Buffer.from(out));
+}
+function decodePdfHexToken(token){
+  let hex=token.slice(1,-1).replace(/\s+/g,'');
+  if(!/^[0-9A-Fa-f]*$/.test(hex)) throw new Error('PDF hex string invalid');
+  if(hex.length%2) hex+='0';
+  return decodePdfTextBytes(Buffer.from(hex,'hex'));
+}
+function decodePdfStringToken(token){
+  return token.startsWith('(')?decodePdfLiteralToken(token):decodePdfHexToken(token);
+}
+function extractTextFromContentStream(bytes){
+  if(bytes.length>MAX_GENERIC_STREAM_BYTES) throw new Error('PDF content stream exceeds decoded byte limit');
+  const source=bytes.toString('latin1');
+  const blocks=[...source.matchAll(/BT\b([\s\S]*?)\bET/g)].map(m=>m[1]);
+  const lines=[];let current='';
+  const flush=()=>{if(current.length){lines.push(current);current='';}};
+  const stringToken='(?:\\((?:\\\\[\\s\\S]|[^\\\\()])*\\)|<(?!<)[0-9A-Fa-f\\s]*>)';
+  const event=new RegExp(
+    `(${stringToken})\\s*Tj\\b|\\[((?:${stringToken}|[^\\]])*)\\]\\s*TJ\\b|(${stringToken})\\s*'|[-+]?\\d*\\.?\\d+\\s+[-+]?\\d*\\.?\\d+\\s+(${stringToken})\\s*"|\\bT\\*\\b|[-+]?\\d*\\.?\\d+\\s+[-+]?\\d*\\.?\\d+\\s+T[dD]\\b`,
+    'g'
+  );
+  for(const block of blocks){
+    let match;
+    while((match=event.exec(block))){
+      const full=match[0];
+      if(/\bT\*$/.test(full)||/\sT[dD]\b$/.test(full)){flush();continue;}
+      if(match[1]){current+=decodePdfStringToken(match[1]);continue;}
+      if(match[2]!==undefined){
+        const strings=[...match[2].matchAll(new RegExp(stringToken,'g'))].map(x=>decodePdfStringToken(x[0]));
+        current+=strings.join('');continue;
+      }
+      if(match[3]){current+=decodePdfStringToken(match[3]);flush();continue;}
+      if(match[4]){current+=decodePdfStringToken(match[4]);flush();continue;}
+    }
+    flush();
+  }
+  return lines.join('\n').replace(/[ \t]+\n/g,'\n').trim();
+}
+function parseGenericPdfObjects(bytes){
+  if(bytes.length>MAX_FILE_BYTES) throw new Error('PDF input exceeds byte limit');
+  const text=bytes.toString('latin1');
+  if(!text.startsWith('%PDF-')) throw new Error('invalid PDF header');
+  if(/\/Encrypt\b/.test(text)) throw new Error('encrypted PDF is unsupported');
+  const objects=new Map(),header=/(\d+)\s+(\d+)\s+obj\b/g;
+  let match,count=0;
+  while((match=header.exec(text))){
+    if(++count>MAX_GENERIC_OBJECTS) throw new Error('PDF object count exceeds limit');
+    const end=text.indexOf('endobj',header.lastIndex);
+    if(end<0) throw new Error(`PDF object ${match[1]} ${match[2]} missing endobj`);
+    const key=`${match[1]} ${match[2]}`;
+    if(objects.has(key)) throw new Error(`PDF duplicate object ${key}`);
+    objects.set(key,{id:Number(match[1]),generation:Number(match[2]),body:text.slice(header.lastIndex,end),offset:match.index});
+    header.lastIndex=end+6;
+  }
+  if(objects.size===0) throw new Error('PDF contains no direct objects');
+  let expandedBytes=0;
+  for(const container of [...objects.values()]){
+    if(!/\/Type\s*\/ObjStm\b/.test(container.body))continue;
+    const n=Number(container.body.match(/\/N\s+(\d+)/)?.[1]);
+    const first=Number(container.body.match(/\/First\s+(\d+)/)?.[1]);
+    if(!Number.isSafeInteger(n)||n<1||n>MAX_GENERIC_OBJECTS||!Number.isSafeInteger(first)||first<0)
+      throw new Error('PDF object stream header invalid');
+    const decoded=decodedObjectStream(container);
+    expandedBytes+=decoded.length;
+    if(expandedBytes>MAX_FILE_BYTES||first>decoded.length)throw new Error('PDF object stream expansion exceeds limit');
+    const headerText=decoded.subarray(0,first).toString('ascii').trim();
+    if(!/^\d+(?:\s+\d+)*$/.test(headerText))throw new Error('PDF object stream index invalid');
+    const index=headerText.split(/\s+/).map(Number);
+    if(index.length!==n*2)throw new Error('PDF object stream index count mismatch');
+    for(let i=0;i<n;i++){
+      const id=index[i*2],offset=index[i*2+1],next=i+1<n?index[(i+1)*2+1]:decoded.length-first;
+      if(!Number.isSafeInteger(id)||id<1||!Number.isSafeInteger(offset)||offset<0||next<offset||first+next>decoded.length)
+        throw new Error('PDF object stream entry invalid');
+      const key=`${id} 0`;
+      if(objects.has(key))throw new Error(`PDF duplicate object ${key}`);
+      if(objects.size>=MAX_GENERIC_OBJECTS)throw new Error('PDF object count exceeds limit');
+      objects.set(key,{id,generation:0,body:decoded.subarray(first+offset,first+next).toString('latin1'),offset:container.offset+i/n});
+    }
+  }
+  return objects;
+}
+function objectRefs(fragment){
+  return [...String(fragment).matchAll(/(\d+)\s+(\d+)\s+R/g)].map(m=>`${m[1]} ${m[2]}`);
+}
+function orderedGenericPages(objects){
+  const catalog=[...objects.values()].find(o=>/\/Type\s*\/Catalog\b/.test(o.body));
+  const rootRef=catalog?.body.match(/\/Pages\s+(\d+)\s+(\d+)\s+R/)?.slice(1,3);
+  const pages=[],visited=new Set();
+  const walk=key=>{
+    if(visited.has(key)) throw new Error('PDF page tree cycle detected');
+    visited.add(key);
+    const obj=objects.get(key);
+    if(!obj) throw new Error(`PDF page tree reference missing: ${key}`);
+    if(/\/Type\s*\/Page\b/.test(obj.body)&&!/\/Type\s*\/Pages\b/.test(obj.body)){pages.push(obj);return;}
+    if(!/\/Type\s*\/Pages\b/.test(obj.body)) throw new Error(`PDF page tree object ${key} has invalid type`);
+    const kids=obj.body.match(/\/Kids\s*\[([\s\S]*?)\]/)?.[1];
+    if(kids===undefined) throw new Error(`PDF Pages object ${key} missing Kids`);
+    for(const ref of objectRefs(kids)) walk(ref);
+  };
+  if(rootRef) walk(`${rootRef[0]} ${rootRef[1]}`);
+  else pages.push(...[...objects.values()].filter(o=>/\/Type\s*\/Page\b/.test(o.body)&&!/\/Type\s*\/Pages\b/.test(o.body)).sort((a,b)=>a.offset-b.offset));
+  if(pages.length>MAX_PAGES) throw new Error(`PDF page count exceeds ${MAX_PAGES}`);
+  return pages;
+}
+function decodedObjectStream(obj){
+  const streamMatch=obj.body.match(/\bstream\r?\n/);
+  if(!streamMatch) throw new Error(`PDF content object ${obj.id} has no stream`);
+  const start=streamMatch.index+streamMatch[0].length;
+  const end=obj.body.indexOf('endstream',start);
+  if(end<0) throw new Error(`PDF content object ${obj.id} missing endstream`);
+  const dictionary=obj.body.slice(0,streamMatch.index);
+  const raw=Buffer.from(obj.body.slice(start,end).replace(/\r?\n$/,''),'latin1');
+  const filter= dictionary.match(/\/Filter\s*\/([A-Za-z0-9]+)/)?.[1] ??
+    dictionary.match(/\/Filter\s*\[\s*\/([A-Za-z0-9]+)\s*\]/)?.[1] ?? null;
+  if(/\/Filter\b/.test(dictionary)&&filter===null) throw new Error('unsupported PDF stream filter chain');
+  if(filter===null) return raw;
+  if(filter!=='FlateDecode') throw new Error(`unsupported PDF stream filter /${filter}`);
+  try{return inflateSync(raw,{maxOutputLength:MAX_GENERIC_STREAM_BYTES});}
+  catch(error){throw new Error(`PDF Flate stream decode failed: ${error?.message??error}`);}
+}
+function pageContentRefs(page){
+  const array=page.body.match(/\/Contents\s*\[([\s\S]*?)\]/)?.[1];
+  if(array!==undefined) return objectRefs(array);
+  const one=page.body.match(/\/Contents\s+(\d+)\s+(\d+)\s+R/);
+  return one?[`${one[1]} ${one[2]}`]:[];
+}
+
+export function readPdfText(input){
+  const bytes=Buffer.isBuffer(input)?Buffer.from(input):Buffer.from(input);
+  const head=bytes.subarray(0,256).toString('latin1');
+  if(head.includes(PROFILE_MARKER)){
+    const exact=parseDeadbytePdf(bytes);
+    return {...exact,partial:false,warnings:[]};
+  }
+  const objects=parseGenericPdfObjects(bytes),pageObjects=orderedGenericPages(objects);
+  const pages=[],warnings=[];
+  for(let i=0;i<pageObjects.length;i++){
+    const refs=pageContentRefs(pageObjects[i]);
+    let pageText='';
+    for(const ref of refs){
+      const obj=objects.get(ref);
+      if(!obj) throw new Error(`PDF content reference missing: ${ref}`);
+      const extracted=extractTextFromContentStream(decodedObjectStream(obj));
+      if(extracted) pageText+=(pageText?'\n':'')+extracted;
+    }
+    if(Buffer.byteLength(pageText,'utf8')>MAX_PAGE_TEXT_BYTES) throw new Error(`PDF page ${i} text exceeds byte limit`);
+    pages.push(pageText);
+    if(refs.length===0) warnings.push(`page ${i+1}: no direct Contents stream`);
+  }
+  return {profile:'generic-pdf-r48',page_count:pages.length,pages,partial:warnings.length>0,warnings};
+}
+
+function normalizeIndexes(values,count){
+  if(!Array.isArray(values)) throw new Error('PDF pageIndexes must be array');
+  const out=[];
+  for(const raw of values){
+    if(!Number.isInteger(raw)) throw new Error('PDF page index must be integer');
+    const n=raw<0?count+raw:raw;
+    if(n>=0&&n<count&&!out.includes(n)) out.push(n);
+  }
+  return out;
+}
+function splitInsertedMarkdown(markdown){
+  if(typeof markdown!=='string') throw new Error('PDF insert markdown must be string');
+  const pages=markdown.split('\f');
+  pages.forEach(assertPageText);
+  return pages;
+}
+
+function rewritePdfRefs(body,resolve){
+  const replace=fragment=>fragment.replace(/(\d+)\s+(\d+)\s+R\b/g,(_,id,generation)=>`${resolve(`${id} ${generation}`)} 0 R`);
+  const stream=body.match(/\bstream\r?\n/);
+  if(!stream)return replace(body);
+  const start=stream.index+stream[0].length,end=body.indexOf('endstream',start);
+  if(end<0)throw new Error('PDF stream missing endstream during rebuild');
+  return replace(body.slice(0,start))+body.slice(start,end)+replace(body.slice(end));
+}
+function inheritedPageEntry(page,objects,name){
+  let current=page,depth=0;
+  while(current&&depth++<64){
+    const array=current.body.match(new RegExp(`/${name}\\s*(\\[[^\\]]*\\])`))?.[1];
+    if(array)return array;
+    const ref=current.body.match(new RegExp(`/${name}\\s+(\\d+\\s+\\d+\\s+R)`))?.[1];
+    if(ref)return ref;
+    const parent=current.body.match(/\/Parent\s+(\d+)\s+(\d+)\s+R/)?.slice(1,3);
+    current=parent?objects.get(`${parent[0]} ${parent[1]}`):null;
+  }
+  if(depth>=64)throw new Error('PDF page inheritance depth exceeds limit');
+  return null;
+}
+function genericPageSet(input,label){
+  const bytes=Buffer.isBuffer(input)?Buffer.from(input):Buffer.from(input);
+  const objects=parseGenericPdfObjects(bytes),pages=orderedGenericPages(objects);
+  return pages.map((page,index)=>({objects,page,label:`${label}:${index}`}));
+}
+function rebuildGenericPdf(pageSet){
+  if(pageSet.length>MAX_PAGES)throw new Error(`PDF page count exceeds ${MAX_PAGES}`);
+  const bodies=new Map([[1,'<< /Type /Catalog /Pages 2 0 R >>'],[2,null]]),memo=new Map();
+  let nextId=3;
+  const sourceKey=(entry,key)=>`${entry.label}|${key}`;
+  const cloneObject=(entry,key)=>{
+    const memoKey=sourceKey(entry,key);
+    if(memo.has(memoKey))return memo.get(memoKey);
+    const source=entry.objects.get(key);
+    if(!source)throw new Error(`PDF rebuild reference missing: ${key}`);
+    if(/\/Type\s*\/(?:Catalog|Pages?)\b/.test(source.body))throw new Error(`PDF rebuild dependency crosses document topology: ${key}`);
+    if(bodies.size>=MAX_GENERIC_OBJECTS)throw new Error('PDF rebuild object count exceeds limit');
+    const id=nextId++;memo.set(memoKey,id);
+    bodies.set(id,rewritePdfRefs(source.body,ref=>cloneObject(entry,ref)));
+    return id;
+  };
+  const pageIds=[];
+  for(const entry of pageSet){
+    const pageKey=`${entry.page.id} ${entry.page.generation}`;
+    const pageId=nextId++,memoKey=sourceKey(entry,pageKey);
+    memo.set(memoKey,pageId);pageIds.push(pageId);bodies.set(pageId,null);
+    let body=entry.page.body.replace(/\/Parent\s+\d+\s+\d+\s+R\b/,'').trim();
+    if(!/\/MediaBox\b/.test(body)){
+      const inherited=inheritedPageEntry(entry.page,entry.objects,'MediaBox');
+      if(inherited)body=body.replace(/>>\s*$/,` /MediaBox ${inherited} >>`);
+    }
+    if(!/\/Resources\b/.test(body)){
+      const inherited=inheritedPageEntry(entry.page,entry.objects,'Resources');
+      if(inherited)body=body.replace(/>>\s*$/,` /Resources ${inherited} >>`);
+    }
+    body=rewritePdfRefs(body,ref=>cloneObject(entry,ref));
+    bodies.set(pageId,body.replace(/>>\s*$/,` /Parent 2 0 R >>`));
+  }
+  bodies.set(2,`<< /Type /Pages /Kids [${pageIds.map(id=>`${id} 0 R`).join(' ')}] /Count ${pageIds.length} >>`);
+  const nl='\n',maxId=nextId-1,offsets=new Array(maxId+1).fill(0);
+  let out=`%PDF-1.4${nl}`;
+  for(let id=1;id<=maxId;id++){
+    const body=bodies.get(id);if(body===undefined||body===null)throw new Error(`PDF rebuild object ${id} missing`);
+    offsets[id]=Buffer.byteLength(out,'latin1');out+=`${id} 0 obj${nl}${body}${nl}endobj${nl}`;
+  }
+  const xref=Buffer.byteLength(out,'latin1');
+  out+=`xref${nl}0 ${maxId+1}${nl}0000000000 65535 f ${nl}`;
+  for(let id=1;id<=maxId;id++)out+=`${String(offsets[id]).padStart(10,'0')} 00000 n ${nl}`;
+  out+=`trailer${nl}<< /Size ${maxId+1} /Root 1 0 R >>${nl}startxref${nl}${xref}${nl}%%EOF${nl}`;
+  const bytes=Buffer.from(out,'latin1');if(bytes.length>MAX_FILE_BYTES)throw new Error('PDF output exceeds byte limit');
+  return {profile:'generic-pdf-r48',mime_type:'application/pdf',page_count:pageSet.length,bytes,bytes_base64:bytes.toString('base64'),bytes_sha256:sha256(bytes),metadata:{rebuilt:true}};
+}
+
+async function editGenericPdf(input,operations,{sourceResolver=null}={}){
+  if(!Array.isArray(operations))throw new Error('PDF operations must be array');
+  if(operations.length>256)throw new Error('PDF operation count exceeds 256');
+  const pages=genericPageSet(input,'base');let serial=0;
+  for(const op of operations){
+    if(!op||typeof op!=='object'||Array.isArray(op))throw new Error('PDF operation invalid');
+    if(op.type==='delete'){
+      for(const index of normalizeIndexes(op.pageIndexes,pages.length).sort((a,b)=>b-a))pages.splice(index,1);
+    }else if(op.type==='insert'){
+      if(!Number.isInteger(op.pageIndex))throw new Error('PDF insert pageIndex must be integer');
+      const at=op.pageIndex<0?pages.length+op.pageIndex:op.pageIndex;
+      if(at<0||at>pages.length)throw new Error('Invalid page index');
+      let inserted;
+      if(op.markdown!==undefined){
+        const generated=createDeadbytePdf(splitInsertedMarkdown(op.markdown));
+        inserted=genericPageSet(generated.bytes,`markdown-${serial++}`);
+      }else if(typeof op.sourcePdfPath==='string'&&op.sourcePdfPath){
+        if(typeof sourceResolver!=='function')throw new Error('PDF source resolver required');
+        inserted=genericPageSet(await sourceResolver(op.sourcePdfPath),`source-${serial++}`);
+      }else throw new Error('No source provided for insert operation');
+      pages.splice(at,0,...inserted);
+      if(pages.length>MAX_PAGES)throw new Error(`PDF page count exceeds ${MAX_PAGES}`);
+    }else throw new Error(`unsupported PDF operation '${String(op.type)}'`);
+  }
+  return rebuildGenericPdf(pages);
+}
+
+export async function editDeadbytePdf(input,operations,{sourceResolver=null}={}){
+  const bytes=Buffer.isBuffer(input)?input:Buffer.from(input);
+  if(!bytes.subarray(0,256).toString('latin1').includes(PROFILE_MARKER))return editGenericPdf(bytes,operations,{sourceResolver});
+  const parsed=parseDeadbytePdf(input);
+  if(!Array.isArray(operations)) throw new Error('PDF operations must be array');
+  if(operations.length>256) throw new Error('PDF operation count exceeds 256');
+  const pages=[...parsed.pages];
+  for(const op of operations){
+    if(!op||typeof op!=='object'||Array.isArray(op)) throw new Error('PDF operation invalid');
+    if(op.type==='delete'){
+      const indexes=normalizeIndexes(op.pageIndexes,pages.length).sort((a,b)=>b-a);
+      for(const index of indexes) pages.splice(index,1);
+      continue;
+    }
+    if(op.type==='insert'){
+      if(!Number.isInteger(op.pageIndex)) throw new Error('PDF insert pageIndex must be integer');
+      const insertPosition=op.pageIndex<0?pages.length+op.pageIndex:op.pageIndex;
+      if(insertPosition<0||insertPosition>pages.length) throw new Error('Invalid page index');
+      let inserted;
+      if(op.markdown!==undefined) inserted=splitInsertedMarkdown(op.markdown);
+      else if(typeof op.sourcePdfPath==='string'&&op.sourcePdfPath){
+        if(typeof sourceResolver!=='function') throw new Error('PDF source resolver required');
+        const source=await sourceResolver(op.sourcePdfPath);
+        inserted=parseDeadbytePdf(source).pages;
+      }else throw new Error('No source provided for insert operation');
+      pages.splice(insertPosition,0,...inserted);
+      if(pages.length>MAX_PAGES) throw new Error(`PDF page count exceeds ${MAX_PAGES}`);
+      continue;
+    }
+    throw new Error(`unsupported PDF operation '${String(op.type)}'`);
+  }
+  return createDeadbytePdf(pages);
+}

package/src/commander-ui-resources.mjs

@@ -0,0 +1,26 @@
+const MIME='text/html;profile=mcp-app';
+const resources=[
+  {uri:'ui://desktop-commander/file-preview',name:'DEADBYTE File Preview',title:'File preview',description:'Bounded local preview of tool output.'},
+  {uri:'ui://desktop-commander/config-editor',name:'DEADBYTE Config Editor',title:'Configuration',description:'Configuration display; changes use set_config_value and native policy enforcement.'}
+];
+
+function html(title){
+  return `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'none'"><title>${title}</title><style>body{font:14px system-ui;margin:16px}pre{white-space:pre-wrap;overflow-wrap:anywhere}</style></head><body><h1>${title}</h1><pre id="output">Waiting for tool output.</pre><script>
+const output=document.getElementById('output');
+window.addEventListener('message',event=>{
+  if(event.source!==window.parent||!event.data||event.data.jsonrpc!=='2.0')return;
+  if(event.data.method!=='ui/notifications/tool-result')return;
+  const value=event.data.params;
+  let text;try{text=JSON.stringify(value,null,2);}catch{return;}
+  if(typeof text==='string')output.textContent=text.slice(0,32768);
+});
+</script></body></html>`;
+}
+
+export function registerCommanderUiResources(server){
+  for(const resource of resources){
+    const text=html(resource.title);
+    server.registerResource(resource.name,resource.uri,{description:resource.description,mimeType:MIME},
+      async()=>({contents:[{uri:resource.uri,mimeType:MIME,text}]}));
+  }
+}