@sylphx/pdf-reader-mcp 1.3.0 → 1.4.0

package/dist/pdf/extractor.js

@@ -1,394 +0,0 @@
-// PDF text and metadata extraction utilities
-import { OPS } from 'pdfjs-dist/legacy/build/pdf.mjs';
-import { PNG } from 'pngjs';
-/**
- * Encode raw pixel data to PNG format
- */
-const encodePixelsToPNG = (pixelData, width, height, channels) => {
-    const png = new PNG({ width, height });
-    // Convert pixel data to RGBA format expected by pngjs
-    if (channels === 4) {
-        // Already RGBA
-        png.data = Buffer.from(pixelData);
-    }
-    else if (channels === 3) {
-        // RGB -> RGBA (add alpha channel)
-        for (let i = 0; i < width * height; i++) {
-            const srcIdx = i * 3;
-            const dstIdx = i * 4;
-            png.data[dstIdx] = pixelData[srcIdx] ?? 0; // R
-            png.data[dstIdx + 1] = pixelData[srcIdx + 1] ?? 0; // G
-            png.data[dstIdx + 2] = pixelData[srcIdx + 2] ?? 0; // B
-            png.data[dstIdx + 3] = 255; // A (fully opaque)
-        }
-    }
-    else if (channels === 1) {
-        // Grayscale -> RGBA
-        for (let i = 0; i < width * height; i++) {
-            const gray = pixelData[i] ?? 0;
-            const dstIdx = i * 4;
-            png.data[dstIdx] = gray; // R
-            png.data[dstIdx + 1] = gray; // G
-            png.data[dstIdx + 2] = gray; // B
-            png.data[dstIdx + 3] = 255; // A
-        }
-    }
-    // Encode to PNG and convert to base64
-    const pngBuffer = PNG.sync.write(png);
-    return pngBuffer.toString('base64');
-};
-/**
- * Extract metadata and page count from a PDF document
- */
-export const extractMetadataAndPageCount = async (pdfDocument, includeMetadata, includePageCount) => {
-    const output = {};
-    if (includePageCount) {
-        output.num_pages = pdfDocument.numPages;
-    }
-    if (includeMetadata) {
-        try {
-            const pdfMetadata = await pdfDocument.getMetadata();
-            const infoData = pdfMetadata.info;
-            if (infoData !== undefined) {
-                output.info = infoData;
-            }
-            const metadataObj = pdfMetadata.metadata;
-            // Check if it has a getAll method (as used in tests)
-            if (typeof metadataObj.getAll === 'function') {
-                output.metadata = metadataObj.getAll();
-            }
-            else {
-                // For real PDF.js metadata, convert to plain object
-                const metadataRecord = {};
-                for (const key in metadataObj) {
-                    if (Object.hasOwn(metadataObj, key)) {
-                        metadataRecord[key] = metadataObj[key];
-                    }
-                }
-                output.metadata = metadataRecord;
-            }
-        }
-        catch (metaError) {
-            console.warn(`[PDF Reader MCP] Error extracting metadata: ${metaError instanceof Error ? metaError.message : String(metaError)}`);
-        }
-    }
-    return output;
-};
-/**
- * Extract text from a single page
- */
-const extractSinglePageText = async (pdfDocument, pageNum, sourceDescription) => {
-    try {
-        const page = await pdfDocument.getPage(pageNum);
-        const textContent = await page.getTextContent();
-        const pageText = textContent.items
-            .map((item) => item.str)
-            .join('');
-        return { page: pageNum, text: pageText };
-    }
-    catch (pageError) {
-        const message = pageError instanceof Error ? pageError.message : String(pageError);
-        console.warn(`[PDF Reader MCP] Error getting text content for page ${String(pageNum)} in ${sourceDescription}: ${message}`);
-        return { page: pageNum, text: `Error processing page: ${message}` };
-    }
-};
-/**
- * Extract text from specified pages (parallel processing for performance)
- */
-export const extractPageTexts = async (pdfDocument, pagesToProcess, sourceDescription) => {
-    // Process all pages in parallel for better performance
-    const extractedPageTexts = await Promise.all(pagesToProcess.map((pageNum) => extractSinglePageText(pdfDocument, pageNum, sourceDescription)));
-    return extractedPageTexts.sort((a, b) => a.page - b.page);
-};
-/**
- * Extract images from a single page
- */
-const extractImagesFromPage = async (page, pageNum) => {
-    const images = [];
-    /* c8 ignore next */
-    try {
-        const operatorList = await page.getOperatorList();
-        // Find all image painting operations
-        const imageIndices = [];
-        for (let i = 0; i < operatorList.fnArray.length; i++) {
-            const op = operatorList.fnArray[i];
-            if (op === OPS.paintImageXObject || op === OPS.paintXObject) {
-                imageIndices.push(i);
-            }
-        }
-        // Extract each image - try sync first, then async if needed
-        const imagePromises = imageIndices.map((imgIndex, arrayIndex) => new Promise((resolve) => {
-            const argsArray = operatorList.argsArray[imgIndex];
-            if (!argsArray || argsArray.length === 0) {
-                resolve(null);
-                return;
-            }
-            const imageName = argsArray[0];
-            // Helper to process image data
-            const processImageData = (imageData) => {
-                if (!imageData || typeof imageData !== 'object') {
-                    return null;
-                }
-                const img = imageData;
-                if (!img.data || !img.width || !img.height) {
-                    return null;
-                }
-                // Determine number of channels based on kind
-                // kind === 1 = grayscale (1 channel), 2 = RGB (3 channels), 3 = RGBA (4 channels)
-                const channels = img.kind === 1 ? 1 : img.kind === 3 ? 4 : 3;
-                const format = img.kind === 1 ? 'grayscale' : img.kind === 3 ? 'rgba' : 'rgb';
-                // Encode raw pixel data to PNG format
-                const pngBase64 = encodePixelsToPNG(img.data, img.width, img.height, channels);
-                return {
-                    page: pageNum,
-                    index: arrayIndex,
-                    width: img.width,
-                    height: img.height,
-                    format,
-                    data: pngBase64,
-                };
-            };
-            // Try to get from commonObjs first if it starts with 'g_'
-            if (imageName.startsWith('g_')) {
-                try {
-                    const imageData = page.commonObjs.get(imageName);
-                    if (imageData) {
-                        const result = processImageData(imageData);
-                        resolve(result);
-                        return;
-                    }
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.warn(`[PDF Reader MCP] Error getting image from commonObjs ${imageName}: ${message}`);
-                }
-            }
-            // Try synchronous get first - if image is already loaded
-            try {
-                const imageData = page.objs.get(imageName);
-                if (imageData !== undefined) {
-                    const result = processImageData(imageData);
-                    resolve(result);
-                    return;
-                }
-            }
-            catch (error) {
-                // Synchronous get failed or not supported, fall through to async
-                const message = error instanceof Error ? error.message : String(error);
-                console.warn(`[PDF Reader MCP] Sync image get failed for ${imageName}, trying async: ${message}`);
-            }
-            // Fallback to async callback-based get with timeout
-            let resolved = false;
-            const timeout = setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    console.warn(`[PDF Reader MCP] Image extraction timeout for ${imageName} on page ${String(pageNum)}`);
-                    resolve(null);
-                }
-            }, 10000); // 10 second timeout as a safety net
-            page.objs.get(imageName, (imageData) => {
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    const result = processImageData(imageData);
-                    resolve(result);
-                }
-            });
-        }));
-        const resolvedImages = await Promise.all(imagePromises);
-        images.push(...resolvedImages.filter((img) => img !== null));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[PDF Reader MCP] Error extracting images from page ${String(pageNum)}: ${message}`);
-    }
-    return images;
-};
-/**
- * Extract images from specified pages
- */
-export const extractImages = async (pdfDocument, pagesToProcess) => {
-    const allImages = [];
-    // Process pages sequentially to avoid overwhelming PDF.js
-    for (const pageNum of pagesToProcess) {
-        try {
-            const page = await pdfDocument.getPage(pageNum);
-            const pageImages = await extractImagesFromPage(page, pageNum);
-            allImages.push(...pageImages);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn(`[PDF Reader MCP] Error getting page ${String(pageNum)} for image extraction: ${message}`);
-        }
-    }
-    return allImages;
-};
-/**
- * Build warnings array for invalid page numbers
- */
-export const buildWarnings = (invalidPages, totalPages) => {
-    if (invalidPages.length === 0) {
-        return [];
-    }
-    return [
-        `Requested page numbers ${invalidPages.join(', ')} exceed total pages (${String(totalPages)}).`,
-    ];
-};
-/**
- * Extract all content (text and images) from a single page with Y-coordinate ordering
- */
-export const extractPageContent = async (pdfDocument, pageNum, includeImages, sourceDescription) => {
-    const contentItems = [];
-    try {
-        const page = await pdfDocument.getPage(pageNum);
-        // Extract text content with Y-coordinates
-        const textContent = await page.getTextContent();
-        // Group text items by Y-coordinate (items on same line have similar Y values)
-        const textByY = new Map();
-        for (const item of textContent.items) {
-            const textItem = item;
-            // transform[5] is the Y coordinate
-            const yCoord = textItem.transform[5];
-            if (yCoord === undefined)
-                continue;
-            const y = Math.round(yCoord);
-            if (!textByY.has(y)) {
-                textByY.set(y, []);
-            }
-            textByY.get(y)?.push(textItem.str);
-        }
-        // Convert grouped text to content items
-        for (const [y, textParts] of textByY.entries()) {
-            const textContent = textParts.join('');
-            if (textContent.trim()) {
-                contentItems.push({
-                    type: 'text',
-                    yPosition: y,
-                    textContent,
-                });
-            }
-        }
-        // Extract images with Y-coordinates if requested
-        if (includeImages) {
-            const operatorList = await page.getOperatorList();
-            // Find all image painting operations
-            const imageIndices = [];
-            for (let i = 0; i < operatorList.fnArray.length; i++) {
-                const op = operatorList.fnArray[i];
-                if (op === OPS.paintImageXObject || op === OPS.paintXObject) {
-                    imageIndices.push(i);
-                }
-            }
-            // Extract each image with its Y-coordinate - try sync first, then async if needed
-            const imagePromises = imageIndices.map((imgIndex, arrayIndex) => new Promise((resolve) => {
-                const argsArray = operatorList.argsArray[imgIndex];
-                if (!argsArray || argsArray.length === 0) {
-                    resolve(null);
-                    return;
-                }
-                const imageName = argsArray[0];
-                // Get transform matrix from the args (if available)
-                let yPosition = 0;
-                if (argsArray.length > 1 && Array.isArray(argsArray[1])) {
-                    const transform = argsArray[1];
-                    const yCoord = transform[5];
-                    if (yCoord !== undefined) {
-                        yPosition = Math.round(yCoord);
-                    }
-                }
-                // Helper to process image data
-                const processImageData = (imageData) => {
-                    if (!imageData || typeof imageData !== 'object') {
-                        return null;
-                    }
-                    const img = imageData;
-                    if (!img.data || !img.width || !img.height) {
-                        return null;
-                    }
-                    // Determine number of channels based on kind
-                    const channels = img.kind === 1 ? 1 : img.kind === 3 ? 4 : 3;
-                    const format = img.kind === 1 ? 'grayscale' : img.kind === 3 ? 'rgba' : 'rgb';
-                    // Encode raw pixel data to PNG format
-                    const pngBase64 = encodePixelsToPNG(img.data, img.width, img.height, channels);
-                    return {
-                        type: 'image',
-                        yPosition,
-                        imageData: {
-                            page: pageNum,
-                            index: arrayIndex,
-                            width: img.width,
-                            height: img.height,
-                            format,
-                            data: pngBase64,
-                        },
-                    };
-                };
-                // Try to get from commonObjs first if it starts with 'g_'
-                if (imageName.startsWith('g_')) {
-                    try {
-                        const imageData = page.commonObjs.get(imageName);
-                        if (imageData) {
-                            const result = processImageData(imageData);
-                            resolve(result);
-                            return;
-                        }
-                        /* c8 ignore next */
-                    }
-                    catch (error) {
-                        /* c8 ignore next */ const message = error instanceof Error ? error.message : String(error);
-                        /* c8 ignore next */ console.warn(
-                        /* c8 ignore next */ `[PDF Reader MCP] Error getting image from commonObjs ${imageName}: ${message}`
-                        /* c8 ignore next */
-                        );
-                    }
-                }
-                // Try synchronous get first - if image is already loaded
-                try {
-                    const imageData = page.objs.get(imageName);
-                    if (imageData !== undefined) {
-                        const result = processImageData(imageData);
-                        resolve(result);
-                        return;
-                    }
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.warn(`[PDF Reader MCP] Sync image get failed for ${imageName}, trying async: ${message}`);
-                }
-                // Fallback to async callback-based get with timeout
-                let resolved = false;
-                const timeout = setTimeout(() => {
-                    if (!resolved) {
-                        resolved = true;
-                        console.warn(`[PDF Reader MCP] Image extraction timeout for ${imageName} on page ${String(pageNum)}`);
-                        resolve(null);
-                    }
-                }, 10000); // 10 second timeout as a safety net
-                page.objs.get(imageName, (imageData) => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        const result = processImageData(imageData);
-                        resolve(result);
-                    }
-                });
-            }));
-            const resolvedImages = await Promise.all(imagePromises);
-            contentItems.push(...resolvedImages.filter((item) => item !== null));
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[PDF Reader MCP] Error extracting page content for page ${String(pageNum)} in ${sourceDescription}: ${message}`);
-        // Return error message as text content
-        return [
-            {
-                type: 'text',
-                yPosition: 0,
-                textContent: `Error processing page: ${message}`,
-            },
-        ];
-    }
-    // Sort by Y-position (descending = top to bottom in PDF coordinates)
-    return contentItems.sort((a, b) => b.yPosition - a.yPosition);
-};

package/dist/pdf/loader.js

@@ -1,53 +0,0 @@
-// PDF document loading utilities
-import fs from 'node:fs/promises';
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { getDocument } from 'pdfjs-dist/legacy/build/pdf.mjs';
-import { resolvePath } from '../utils/pathUtils.js';
-/**
- * Load a PDF document from a local file path or URL
- * @param source - Object containing either path or url
- * @param sourceDescription - Description for error messages
- * @returns PDF document proxy
- */
-export const loadPdfDocument = async (source, sourceDescription) => {
-    let pdfDataSource;
-    try {
-        if (source.path) {
-            const safePath = resolvePath(source.path);
-            const buffer = await fs.readFile(safePath);
-            pdfDataSource = new Uint8Array(buffer);
-        }
-        else if (source.url) {
-            pdfDataSource = { url: source.url };
-        }
-        else {
-            throw new McpError(ErrorCode.InvalidParams, `Source ${sourceDescription} missing 'path' or 'url'.`);
-        }
-    }
-    catch (err) {
-        if (err instanceof McpError) {
-            throw err;
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        const errorCode = ErrorCode.InvalidRequest;
-        if (typeof err === 'object' &&
-            err !== null &&
-            'code' in err &&
-            err.code === 'ENOENT' &&
-            source.path) {
-            throw new McpError(errorCode, `File not found at '${source.path}'.`, {
-                cause: err instanceof Error ? err : undefined,
-            });
-        }
-        throw new McpError(errorCode, `Failed to prepare PDF source ${sourceDescription}. Reason: ${message}`, { cause: err instanceof Error ? err : undefined });
-    }
-    const loadingTask = getDocument(pdfDataSource);
-    try {
-        return await loadingTask.promise;
-    }
-    catch (err) {
-        console.error(`[PDF Reader MCP] PDF.js loading error for ${sourceDescription}:`, err);
-        const message = err instanceof Error ? err.message : String(err);
-        throw new McpError(ErrorCode.InvalidRequest, `Failed to load PDF document from ${sourceDescription}. Reason: ${message || 'Unknown loading error'}`, { cause: err instanceof Error ? err : undefined });
-    }
-};

package/dist/pdf/parser.js

@@ -1,96 +0,0 @@
-// Page range parsing utilities
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-const MAX_RANGE_SIZE = 10000; // Prevent infinite loops for open ranges
-/**
- * Parse a single range part (e.g., "1-3", "5", "7-")
- */
-const parseRangePart = (part, pages) => {
-    const trimmedPart = part.trim();
-    if (trimmedPart.includes('-')) {
-        const splitResult = trimmedPart.split('-');
-        const startStr = splitResult[0] || '';
-        const endStr = splitResult[1];
-        const start = parseInt(startStr, 10);
-        const end = endStr === '' || endStr === undefined ? Infinity : parseInt(endStr, 10);
-        if (Number.isNaN(start) || Number.isNaN(end) || start <= 0 || start > end) {
-            throw new Error(`Invalid page range values: ${trimmedPart}`);
-        }
-        const practicalEnd = Math.min(end, start + MAX_RANGE_SIZE);
-        for (let i = start; i <= practicalEnd; i++) {
-            pages.add(i);
-        }
-        if (end === Infinity && practicalEnd === start + MAX_RANGE_SIZE) {
-            console.warn(`[PDF Reader MCP] Open-ended range starting at ${String(start)} was truncated at page ${String(practicalEnd)}.`);
-        }
-    }
-    else {
-        const page = parseInt(trimmedPart, 10);
-        if (Number.isNaN(page) || page <= 0) {
-            throw new Error(`Invalid page number: ${trimmedPart}`);
-        }
-        pages.add(page);
-    }
-};
-/**
- * Parse page range string into array of page numbers
- * @param ranges - Range string (e.g., "1-3,5,7-10")
- * @returns Sorted array of unique page numbers
- */
-export const parsePageRanges = (ranges) => {
-    const pages = new Set();
-    const parts = ranges.split(',');
-    for (const part of parts) {
-        parseRangePart(part, pages);
-    }
-    // This should never happen as parseRangePart would have thrown an error
-    // if no valid pages were found, but we keep this as a safety check
-    /* c8 ignore next */
-    if (pages.size === 0) {
-        throw new Error('Page range string resulted in zero valid pages.');
-    }
-    return Array.from(pages).sort((a, b) => a - b);
-};
-/**
- * Get target pages from page specification
- * @param sourcePages - Page specification (string or array)
- * @param sourceDescription - Description for error messages
- * @returns Array of page numbers or undefined
- */
-export const getTargetPages = (sourcePages, sourceDescription) => {
-    if (!sourcePages) {
-        return undefined;
-    }
-    try {
-        if (typeof sourcePages === 'string') {
-            return parsePageRanges(sourcePages);
-        }
-        // Array of page numbers
-        if (sourcePages.some((p) => !Number.isInteger(p) || p <= 0)) {
-            throw new Error('Page numbers in array must be positive integers.');
-        }
-        const uniquePages = [...new Set(sourcePages)].sort((a, b) => a - b);
-        if (uniquePages.length === 0) {
-            throw new Error('Page specification resulted in an empty set of pages.');
-        }
-        return uniquePages;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new McpError(ErrorCode.InvalidParams, `Invalid page specification for source ${sourceDescription}: ${message}`);
-    }
-};
-/**
- * Determine which pages to process based on target pages and document size
- */
-export const determinePagesToProcess = (targetPages, totalPages, includeFullText) => {
-    if (targetPages) {
-        const pagesToProcess = targetPages.filter((p) => p <= totalPages);
-        const invalidPages = targetPages.filter((p) => p > totalPages);
-        return { pagesToProcess, invalidPages };
-    }
-    if (includeFullText) {
-        const pagesToProcess = Array.from({ length: totalPages }, (_, i) => i + 1);
-        return { pagesToProcess, invalidPages: [] };
-    }
-    return { pagesToProcess: [], invalidPages: [] };
-};

package/dist/schemas/readPdf.js

@@ -1,59 +0,0 @@
-// Zod validation schemas for PDF reading
-import { z } from 'zod';
-// Schema for page specification (array of numbers or range string)
-export const pageSpecifierSchema = z.union([
-    z.array(z.number().int().min(1)).min(1).describe('Array of page numbers (1-based)'),
-    z
-        .string()
-        .min(1)
-        .refine((val) => /^[0-9,-]+$/.test(val.replace(/\s/g, '')), {
-        message: 'Page string must contain only numbers, commas, and hyphens.',
-    })
-        .describe('Page range string (e.g., "1-5,10,15-20")'),
-]);
-// Schema for a single PDF source (path or URL)
-export const pdfSourceSchema = z
-    .object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Path to the local PDF file (absolute or relative to cwd).'),
-    url: z.string().url().optional().describe('URL of the PDF file.'),
-    pages: pageSpecifierSchema
-        .optional()
-        .describe("Extract text only from specific pages (1-based) or ranges for this source. If provided, 'include_full_text' is ignored for this source."),
-})
-    .strict()
-    .refine((data) => !!(data.path && !data.url) || !!(!data.path && data.url), {
-    message: "Each source must have either 'path' or 'url', but not both.",
-});
-// Schema for the read_pdf tool arguments
-export const readPdfArgsSchema = z
-    .object({
-    sources: z
-        .array(pdfSourceSchema)
-        .min(1)
-        .describe('An array of PDF sources to process, each can optionally specify pages.'),
-    include_full_text: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Include the full text content of each PDF (only if 'pages' is not specified for that source)."),
-    include_metadata: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Include metadata and info objects for each PDF.'),
-    include_page_count: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Include the total number of pages for each PDF.'),
-    include_images: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Extract and include embedded images from the PDF pages as base64-encoded data.'),
-})
-    .strict();

package/dist/types/pdf.js

@@ -1,2 +0,0 @@
-// PDF-related TypeScript type definitions
-export {};

package/dist/utils/pathUtils.js

@@ -1,25 +0,0 @@
-// Removed unused import: import { fileURLToPath } from 'url';
-import path from 'node:path';
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-// Use the server's current working directory as the project root.
-// This relies on the process launching the server to set the CWD correctly.
-export const PROJECT_ROOT = process.cwd();
-console.info(`[Filesystem MCP - pathUtils] Project Root determined from CWD: ${PROJECT_ROOT}`); // Use info instead of log
-/**
- * Resolves a user-provided path, accepting both absolute and relative paths.
- * Relative paths are resolved against the current working directory (PROJECT_ROOT).
- * @param userPath The path provided by the user (absolute or relative).
- * @returns The resolved absolute path.
- */
-export const resolvePath = (userPath) => {
-    if (typeof userPath !== 'string') {
-        throw new McpError(ErrorCode.InvalidParams, 'Path must be a string.');
-    }
-    const normalizedUserPath = path.normalize(userPath);
-    // If absolute path, return it normalized
-    if (path.isAbsolute(normalizedUserPath)) {
-        return normalizedUserPath;
-    }
-    // If relative path, resolve against the PROJECT_ROOT (cwd)
-    return path.resolve(PROJECT_ROOT, normalizedUserPath);
-};