@remcp/runtime 0.2.152 → 0.2.154

package/src/extended/documents-filesystem.mjs

@@ -0,0 +1,270 @@
+import path from 'node:path';
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { copyFile, link, lstat, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { readDocxXmlText, readPdfText } from '../documents.mjs';
+import { openDirectoryPath } from '../tools/files.mjs';
+import { resolveSafePath, text } from '../util.mjs';
+import {
+  clamp,
+  commandExists,
+  escapePowerShellSingle,
+  jsonResult,
+  optionalString,
+  removeTemp,
+  requireEnum,
+  runFile,
+  runPowerShell,
+  tempDir,
+  unavailable,
+} from './common.mjs';
+
+// Internal OOXML/PDF helpers; keep all file reads descriptor-bound and size-limited.
+
+export function xmlEscape(value) {
+  return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+export 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);
+
+export function descriptorAnchorsAvailable() {
+  return process.platform === 'linux' && Boolean(constants.O_NOFOLLOW) && Boolean(constants.O_DIRECTORY);
+}
+
+export 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;
+  }
+}
+
+export async function openDocumentDirectoryPath(directory, { create = false } = {}) {
+  const opened = await openDirectoryPath(directory, { create });
+  return { ...opened, descriptorBound:opened.anchor !== directory || process.platform === 'linux' };
+}
+
+export 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;
+  }
+}
+
+export 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);
+}
+
+export 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();
+  }
+}
+
+export 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();
+  }
+}
+
+export 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;
+  }
+}
+
+export 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);
+  }
+}
+
+export 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;
+}
+
+export function safeArchiveEntry(name) {
+  const normalized = String(name || '').replace(/\\/g, '/');
+  if (!normalized || normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized)) return false;
+  return !normalized.split('/').includes('..');
+}
+
+export 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}`);
+}
+
+export 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);
+  }
+}
+
+export 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 });
+}
+
+export 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(() => {});
+  }
+}
+
+export 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}`);
+}
+
+export 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');
+}

package/src/extended/documents-reading.mjs

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { copyFile, link, lstat, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { readDocxXmlText, readPdfText } from '../documents.mjs';
+import { openDirectoryPath } from '../tools/files.mjs';
+import { resolveSafePath, text } from '../util.mjs';
+import {
+  clamp,
+  commandExists,
+  escapePowerShellSingle,
+  jsonResult,
+  optionalString,
+  removeTemp,
+  requireEnum,
+  runFile,
+  runPowerShell,
+  tempDir,
+  unavailable,
+} from './common.mjs';
+
+import { xmlEscape, xmlUnescape, descriptorAnchorsAvailable, openDocumentSource, openDocumentDirectoryPath, createAnchoredTempDirectory, readBounded, readDocumentFile, copyRegularNoFollow, snapshotDocumentFile, assertSafeExtractedTree, safePdfPattern, safeArchiveEntry, validateZipArchive, extractZip, createZip, commitDocumentOutput, ensureCreateTargetIsNew, writeOoxmlPart } from './documents-filesystem.mjs';
+
+export 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;
+}
+
+export 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;
+}
+
+export 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>');
+}
+
+export 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 };
+}
+
+export 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(''));
+}
+
+export 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;
+}
+
+export 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);
+  }
+}
+
+export 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);
+  }
+}
+
+export 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');
+}