@remcp/runtime 0.2.152 → 0.2.154

package/src/extended/documents.mjs

@@ -20,392 +20,9 @@ import {
   unavailable,
 } from './common.mjs';
 
-function xmlEscape(value) {
-  return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
-}
-function xmlUnescape(value) {
-  return String(value).replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
-}
-
-const MAX_OOXML_ENTRIES = 10_000;
-const MAX_OOXML_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
-const MAX_DOCUMENT_BYTES = 128 * 1024 * 1024;
-const DOCUMENT_READ_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW || 0) | (constants.O_NONBLOCK || 0);
-
-function descriptorAnchorsAvailable() {
-  return process.platform === 'linux' && Boolean(constants.O_NOFOLLOW) && Boolean(constants.O_DIRECTORY);
-}
-
-async function openDocumentSource(filePath) {
-  if (!descriptorAnchorsAvailable()) {
-    const handle = await open(filePath, DOCUMENT_READ_FLAGS);
-    try {
-      const info = await handle.stat();
-      if (!info.isFile()) throw new Error('Document path must be a regular file');
-      return { handle, close: () => handle.close() };
-    } catch (error) {
-      await handle.close().catch(() => {});
-      throw error;
-    }
-  }
-  const parent = await openDirectoryPath(path.dirname(filePath));
-  let handle;
-  try {
-    handle = await open(path.join(parent.anchor, path.basename(filePath)), DOCUMENT_READ_FLAGS);
-    const info = await handle.stat();
-    if (!info.isFile()) throw new Error('Document path must be a regular file');
-    return {
-      handle,
-      close: async () => {
-        try { await handle.close(); }
-        finally { await parent.close().catch(() => {}); }
-      },
-    };
-  } catch (error) {
-    if (handle) await handle.close().catch(() => {});
-    await parent.close().catch(() => {});
-    throw error;
-  }
-}
-
-async function openDocumentDirectoryPath(directory, { create = false } = {}) {
-  const opened = await openDirectoryPath(directory, { create });
-  return { ...opened, descriptorBound:opened.anchor !== directory || process.platform === 'linux' };
-}
-
-async function createAnchoredTempDirectory(parent, prefix) {
-  const directory = await openDocumentDirectoryPath(parent, { create:true });
-  try {
-    const childAnchor = directory.descriptorBound === false
-      ? directory.anchor
-      : directory.anchor.replace('/proc/self/fd/', `/proc/${process.pid}/fd/`);
-    const directoryPath = await mkdtemp(path.join(childAnchor, prefix));
-    return { path:directoryPath, close:directory.close };
-  } catch (error) {
-    await directory.close().catch(() => {});
-    throw error;
-  }
-}
-
-async function readBounded(handle, maximum, label) {
-  const chunks = [];
-  const buffer = Buffer.allocUnsafe(1024 * 1024);
-  let offset = 0;
-  for (;;) {
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
-    if (!bytesRead) break;
-    if (!Number.isSafeInteger(offset + bytesRead) || offset + bytesRead > maximum) {
-      throw new Error(`${label} exceeds the ${maximum}-byte safety limit`);
-    }
-    chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
-    offset += bytesRead;
-  }
-  return Buffer.concat(chunks, offset);
-}
-
-async function readDocumentFile(filePath) {
-  const opened = await openDocumentSource(filePath);
-  try {
-    const info = await opened.handle.stat();
-    if (!info.isFile()) throw new Error('Document path must be a regular file');
-    if (info.size > MAX_DOCUMENT_BYTES) throw new Error(`Document is too large (maximum ${MAX_DOCUMENT_BYTES} bytes)`);
-    return await readBounded(opened.handle, MAX_DOCUMENT_BYTES, 'Document');
-  } finally {
-    await opened.close();
-  }
-}
-
-async function copyRegularNoFollow(source, destination) {
-  const opened = await openDocumentSource(source);
-  try {
-    const info = await opened.handle.stat();
-    if (!info.isFile()) throw new Error('Document path must be a regular file');
-    if (info.size > MAX_DOCUMENT_BYTES) throw new Error(`Document is too large (maximum ${MAX_DOCUMENT_BYTES} bytes)`);
-    const destinationHandle = await open(destination, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0), 0o600);
-    try {
-      const data = await readBounded(opened.handle, MAX_DOCUMENT_BYTES, 'Document');
-      await destinationHandle.writeFile(data);
-    } finally {
-      await destinationHandle.close();
-    }
-  } finally {
-    await opened.close();
-  }
-}
-
-async function snapshotDocumentFile(filePath) {
-  const dir = await tempDir('remcp-pdf-input-');
-  const snapshot = path.join(dir, `input-${randomUUID()}.pdf`);
-  try {
-    await copyRegularNoFollow(filePath, snapshot);
-    return { dir, path: snapshot };
-  } catch (error) {
-    await removeTemp(dir);
-    throw error;
-  }
-}
-
-async function assertSafeExtractedTree(root, state = { entries: 0 }) {
-  const info = await lstat(root);
-  if (info.isSymbolicLink()) throw new Error('OOXML archive contains a symbolic link');
-  if (!info.isDirectory() && !info.isFile()) throw new Error('OOXML archive contains a special file');
-  state.entries += 1;
-  if (state.entries > MAX_OOXML_ENTRIES) throw new Error('OOXML archive has too many extracted entries');
-  if (!info.isDirectory()) return;
-  for (const entry of await readdir(root, { withFileTypes: true })) {
-    await assertSafeExtractedTree(path.join(root, entry.name), state);
-  }
-}
-
-function safePdfPattern(value, fallback) {
-  const pattern = String(value || fallback);
-  if (!pattern || pattern.length > 240 || pattern.includes('\0') || path.isAbsolute(pattern) || /[\\/]/.test(pattern) || pattern.split(/[\\/]/).includes('..')) {
-    throw new Error('PDF split pattern must be a filename without path separators');
-  }
-  return pattern;
-}
-
-function safeArchiveEntry(name) {
-  const normalized = String(name || '').replace(/\\/g, '/');
-  if (!normalized || normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized)) return false;
-  return !normalized.split('/').includes('..');
-}
-
-async function validateZipArchive(source) {
-  if (process.platform === 'win32') {
-    const script = `Add-Type -AssemblyName System.IO.Compression.FileSystem;$z=[IO.Compression.ZipFile]::OpenRead('${escapePowerShellSingle(source)}');try{$count=$z.Entries.Count;$total=0;foreach($e in $z.Entries){$n=$e.FullName.Replace('\\','/');if([IO.Path]::IsPathRooted($n) -or $n.StartsWith('/') -or ($n.Split('/') -contains '..')){throw ('unsafe archive path: '+$n)};$total += $e.Length};if($count -gt ${MAX_OOXML_ENTRIES}){throw 'too many archive entries'};if($total -gt ${MAX_OOXML_UNCOMPRESSED_BYTES}){throw 'archive expands beyond the OOXML limit'};[pscustomobject]@{count=$count;total=$total}|ConvertTo-Json -Compress}finally{$z.Dispose()}`;
-    await runPowerShell(script, { label:'validate OOXML archive', timeout:30_000 });
-    return;
-  }
-  if (!commandExists('unzip')) unavailable('OOXML document editing', 'unzip is required');
-  const names = await runFile('unzip', ['-Z','-1',source], { label:'inspect OOXML archive', timeout:30_000, maxBuffer:16 * 1024 * 1024 });
-  const entries = names.stdout.split(/\r?\n/).filter(Boolean);
-  if (entries.length > MAX_OOXML_ENTRIES) throw new Error(`OOXML archive has too many entries (${entries.length}; max ${MAX_OOXML_ENTRIES})`);
-  const unsafe = entries.find(name => !safeArchiveEntry(name));
-  if (unsafe) throw new Error(`OOXML archive contains an unsafe path: ${unsafe}`);
-  const details = await runFile('unzip', ['-Z','-v',source], { label:'inspect OOXML entry types', timeout:30_000, maxBuffer:16 * 1024 * 1024 });
-  if (/symbolic link|Unix file attributes \([^)]*\b12\d{4}/i.test(details.stdout)) throw new Error('OOXML archive contains a symbolic link');
-  const totals = await runFile('unzip', ['-Z','-t',source], { label:'inspect OOXML archive size', timeout:30_000 });
-  const uncompressed = Number(totals.stdout.match(/(?:^|,\s)([0-9]+) bytes uncompressed/)?.[1] || 0);
-  if (uncompressed > MAX_OOXML_UNCOMPRESSED_BYTES) throw new Error(`OOXML archive expands to ${uncompressed} bytes; max ${MAX_OOXML_UNCOMPRESSED_BYTES}`);
-}
-
-async function extractZip(source, destination) {
-  const sourceDirectory = await tempDir('remcp-ooxml-source-');
-  const sourceCopy = path.join(sourceDirectory, 'source.zip');
-  try {
-    await copyRegularNoFollow(source, sourceCopy);
-    await validateZipArchive(sourceCopy);
-    await mkdir(destination, { recursive:true });
-    if (process.platform === 'win32') {
-      await runPowerShell(`Add-Type -AssemblyName System.IO.Compression.FileSystem;[IO.Compression.ZipFile]::ExtractToDirectory('${escapePowerShellSingle(sourceCopy)}','${escapePowerShellSingle(destination)}')`, { label:'extract OOXML archive', timeout:30_000 });
-    } else {
-      if (!commandExists('unzip')) unavailable('OOXML document editing', 'unzip is required');
-      await runFile('unzip', ['-qq',sourceCopy,'-d',destination], { label:'extract OOXML archive', timeout:30_000 });
-    }
-    await assertSafeExtractedTree(destination);
-  } finally {
-    await removeTemp(sourceDirectory);
-  }
-}
-
-async function createZip(sourceDir, destination) {
-  await rm(destination, { force:true }).catch(() => {});
-  if (process.platform === 'win32') {
-    await runPowerShell(`Add-Type -AssemblyName System.IO.Compression.FileSystem;[IO.Compression.ZipFile]::CreateFromDirectory('${escapePowerShellSingle(sourceDir)}','${escapePowerShellSingle(destination)}',[IO.Compression.CompressionLevel]::Optimal,$false)`, { label:'create OOXML archive', timeout:30_000 });
-    return;
-  }
-  if (!commandExists('zip')) unavailable('OOXML document editing', 'zip is required');
-  await runFile('zip', ['-qr',destination,'.'], { cwd:sourceDir, label:'create OOXML archive', timeout:30_000 });
-}
-
-async function commitDocumentOutput(staged, destination, { noReplace = false } = {}) {
-  const parentDirectory = await openDocumentDirectoryPath(path.dirname(destination));
-  const parentAnchor = parentDirectory.anchor;
-  const destinationPath = path.join(parentAnchor, path.basename(destination));
-  try {
-    if (noReplace) {
-      await link(staged, destinationPath);
-      await unlink(staged);
-      return;
-    }
-    try {
-      await rename(staged, destinationPath);
-      return;
-    } catch (error) {
-      if (!['EEXIST', 'EPERM', 'ENOTEMPTY'].includes(error?.code)) throw error;
-    }
-    const backup = path.join(parentAnchor, `.${path.basename(destination)}.remcp-old-${randomUUID()}`);
-    let moved = false;
-    try {
-      await rename(destinationPath, backup);
-      moved = true;
-      await rename(staged, destinationPath);
-      await rm(backup, { force: true }).catch(() => {});
-    } catch (error) {
-      if (moved && !await lstat(destinationPath).catch(() => null)) await rename(backup, destinationPath).catch(() => {});
-      throw error;
-    }
-  } finally {
-    await parentDirectory.close().catch(() => {});
-  }
-}
-
-async function ensureCreateTargetIsNew(filePath) {
-  try {
-    await stat(filePath);
-  } catch (error) {
-    if (error?.code === 'ENOENT') return;
-    throw error;
-  }
-  throw new Error(`Cannot create document because path already exists: ${filePath}`);
-}
-
-async function writeOoxmlPart(root, relative, content) {
-  const target = path.join(root, ...relative.split('/'));
-  await mkdir(path.dirname(target), { recursive:true });
-  await writeFile(target, content, 'utf8');
-}
-
-function newWorksheetName(value) {
-  const name = optionalString(value) || 'Sheet1';
-  if (name.length > 31) throw new Error('Worksheet name must be 31 characters or fewer');
-  if (/[\\/*?:\[\]]/.test(name) || name.startsWith("'") || name.endsWith("'")) {
-    throw new Error('Worksheet name contains characters Excel does not allow');
-  }
-  return name;
-}
-
-async function createBlankXlsxTree(root, sheetName) {
-  const name = newWorksheetName(sheetName);
-  await writeOoxmlPart(root, '[Content_Types].xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/></Types>');
-  await writeOoxmlPart(root, '_rels/.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>');
-  await writeOoxmlPart(root, 'xl/workbook.xml', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="${xmlEscape(name)}" sheetId="1" r:id="rId1"/></sheets></workbook>`);
-  await writeOoxmlPart(root, 'xl/_rels/workbook.xml.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/></Relationships>');
-  await writeOoxmlPart(root, 'xl/worksheets/sheet1.xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData></sheetData></worksheet>');
-  return name;
-}
-
-async function createBlankDocxTree(root) {
-  await writeOoxmlPart(root, '[Content_Types].xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/></Types>');
-  await writeOoxmlPart(root, '_rels/.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>');
-  await writeOoxmlPart(root, 'word/document.xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:sectPr><w:pgSz w:w="12240" w:h="15840"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="708" w:footer="708" w:gutter="0"/></w:sectPr></w:body></w:document>');
-}
-
-function workbookSheetPath(workbookXml, relsXml, requestedName) {
-  const sheets = [...workbookXml.matchAll(/<sheet\b[^>]*name="([^"]+)"[^>]*(?:r:id|id)="([^"]+)"[^>]*\/?>(?:<\/sheet>)?/g)].map(match => ({ name:xmlUnescape(match[1]), rid:match[2] }));
-  const sheet = requestedName ? sheets.find(item => item.name.toLowerCase() === requestedName.toLowerCase()) : sheets[0];
-  if (!sheet) throw new Error(requestedName ? `Worksheet not found: ${requestedName}` : 'Workbook contains no worksheets');
-  const relationships = [...relsXml.matchAll(/<Relationship\b[^>]*Id="([^"]+)"[^>]*Target="([^"]+)"[^>]*\/?>/g)].map(match => ({ id:match[1], target:match[2] }));
-  const rel = relationships.find(item => item.id === sheet.rid);
-  if (!rel) throw new Error(`Relationship for worksheet ${sheet.name} was not found`);
-  const target = rel.target.replace(/^\//, '').replace(/\\/g, '/');
-  if (!safeArchiveEntry(target)) throw new Error(`Worksheet relationship contains an unsafe path: ${target}`);
-  const relative = path.posix.normalize(target.startsWith('xl/') ? target : path.posix.join('xl', target));
-  if (!relative.startsWith('xl/') || relative.split('/').includes('..')) throw new Error(`Worksheet relationship escapes the workbook: ${target}`);
-  return { name:sheet.name, relative };
-}
-
-function readSharedStrings(xml) {
-  if (!xml) return [];
-  return [...xml.matchAll(/<si\b[^>]*>([\s\S]*?)<\/si>/g)].map(match => [...match[1].matchAll(/<t\b[^>]*>([\s\S]*?)<\/t>/g)].map(textMatch => xmlUnescape(textMatch[1])).join(''));
-}
-
-function readWorksheetCells(xml, sharedStrings, maxCells) {
-  const cells = [];
-  const pattern = /<c\b([^>]*)\br="([A-Z]+\d+)"([^>]*)>([\s\S]*?)<\/c>|<c\b([^>]*)\br="([A-Z]+\d+)"([^>]*)\/>/g;
-  for (const match of xml.matchAll(pattern)) {
-    if (cells.length >= maxCells) break;
-    const attrs = `${match[1] || match[5] || ''}${match[3] || match[7] || ''}`;
-    const ref = match[2] || match[6];
-    const body = match[4] || '';
-    const type = attrs.match(/\bt="([^"]+)"/)?.[1] || '';
-    const formula = body.match(/<f\b[^>]*>([\s\S]*?)<\/f>/)?.[1];
-    const raw = body.match(/<v\b[^>]*>([\s\S]*?)<\/v>/)?.[1] ?? '';
-    let value;
-    if (type === 's') value = sharedStrings[Number(raw)] ?? raw;
-    else if (type === 'inlineStr') value = [...body.matchAll(/<t\b[^>]*>([\s\S]*?)<\/t>/g)].map(item => xmlUnescape(item[1])).join('');
-    else if (type === 'b') value = raw === '1';
-    else if (raw !== '' && Number.isFinite(Number(raw))) value = Number(raw);
-    else value = xmlUnescape(raw);
-    cells.push({ ref, value, ...(formula ? { formula:xmlUnescape(formula) } : {}) });
-  }
-  return cells;
-}
-
-async function readXlsx(filePath, args) {
-  const dir = await tempDir('remcp-xlsx-read-');
-  try {
-    // extractZip already snapshots the user-approved source into a private temp file
-    // before invoking unzip. A second snapshot here used to re-open ReMCP's own temp
-    // path through allowedRoots, so read_document failed whenever confinement was on.
-    await extractZip(filePath, dir);
-    const workbook = await readFile(path.join(dir,'xl','workbook.xml'),'utf8');
-    const rels = await readFile(path.join(dir,'xl','_rels','workbook.xml.rels'),'utf8');
-    const sheet = workbookSheetPath(workbook, rels, optionalString(args.sheet));
-    const worksheet = await readFile(path.join(dir,...sheet.relative.split('/')),'utf8');
-    let shared = [];
-    try { shared = readSharedStrings(await readFile(path.join(dir,'xl','sharedStrings.xml'),'utf8')); } catch {}
-    const cells = readWorksheetCells(worksheet, shared, clamp(args.max_cells,5000,1,50_000));
-    return { kind:'xlsx', sheet:sheet.name, count:cells.length, cells };
-  } finally {
-    await removeTemp(dir);
-  }
-}
-
-async function readDocxDocument(filePath) {
-  const dir = await tempDir('remcp-docx-read-');
-  try {
-    await extractZip(filePath, dir);
-    let xml;
-    try {
-      xml = await readFile(path.join(dir, 'word', 'document.xml'), 'utf8');
-    } catch (error) {
-      if (error?.code === 'ENOENT') {
-        throw new Error('This file is not a readable .docx (word/document.xml is missing)');
-      }
-      throw error;
-    }
-    return readDocxXmlText(xml);
-  } finally {
-    await removeTemp(dir);
-  }
-}
-
-async function readPdfDocument(data) {
-  try {
-    return readPdfText(data);
-  } catch (builtinError) {
-    if (commandExists('pdftotext')) {
-      const dir = await tempDir('remcp-pdf-read-');
-      try {
-        const snapshot = path.join(dir, 'input.pdf');
-        await writeFile(snapshot, data, { mode: 0o600 });
-        const extracted = await runFile('pdftotext', ['-enc','UTF-8',snapshot,'-'], {
-          label:'PDF text extraction',
-          timeout:60_000,
-          allowFailure:true,
-        });
-        const fallbackText = String(extracted.stdout || '').replace(/\f/g, '\n').trim();
-        if (extracted.code === 0 && fallbackText) return fallbackText;
-      } finally {
-        await removeTemp(dir);
-      }
-    }
-    throw builtinError;
-  }
-}
-
-export async function readDocument(args) {
-  const filePath = await resolveSafePath(args.path,'path');
-  const lower = filePath.toLowerCase();
-  if (lower.endsWith('.docx')) return text(await readDocxDocument(filePath));
-  if (lower.endsWith('.xlsx')) return jsonResult(await readXlsx(filePath,args));
-  const data = await readDocumentFile(filePath);
-  if (lower.endsWith('.pdf')) return text(await readPdfDocument(data));
-  if (/\.(txt|md|csv|json|xml|yaml|yml)$/i.test(lower)) return text(data.toString('utf8'));
-  throw new Error('read_document supports PDF, DOCX, XLSX, TXT, Markdown, CSV, JSON, XML, YAML');
-}
+import { xmlEscape, xmlUnescape, descriptorAnchorsAvailable, openDocumentSource, openDocumentDirectoryPath, createAnchoredTempDirectory, readBounded, readDocumentFile, copyRegularNoFollow, snapshotDocumentFile, assertSafeExtractedTree, safePdfPattern, safeArchiveEntry, validateZipArchive, extractZip, createZip, commitDocumentOutput, ensureCreateTargetIsNew, writeOoxmlPart } from './documents-filesystem.mjs';
+import { newWorksheetName, createBlankXlsxTree, createBlankDocxTree, workbookSheetPath, readSharedStrings, readWorksheetCells, readXlsx, readDocxDocument, readPdfDocument, readDocument } from './documents-reading.mjs';
+export { readDocument };
 
 function cellXml(ref, value, formula) {
   if (formula != null) return `<c r="${ref}"><f>${xmlEscape(String(formula).replace(/^=/,''))}</f></c>`;