@sylphx/pdf-reader-mcp 1.2.0 → 1.3.0

package/dist/handlers/readPdf.js

@@ -70,7 +70,7 @@ const processSingleSource = async (source, options) => {
         let errorMessage = `Failed to process PDF from ${sourceDescription}.`;
         if (error instanceof McpError) {
             errorMessage = error.message;
-        }
+        } /* c8 ignore next */
         else if (error instanceof Error) {
             errorMessage += ` Reason: ${error.message}`;
         }
@@ -93,9 +93,11 @@ export const handleReadPdfFunc = async (args) => {
     }
     catch (error) {
         if (error instanceof z.ZodError) {
-            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${error.errors.map((e) => `${e.path.join('.')} (${e.message})`).join(', ')}`);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${error.issues.map((e) => `${e.path.join('.')} (${e.message})`).join(', ')}`);
         }
+        /* c8 ignore next */
         const message = error instanceof Error ? error.message : String(error);
+        /* c8 ignore next */
         throw new McpError(ErrorCode.InvalidParams, `Argument validation failed: ${message}`);
     }
     const { sources, include_full_text, include_metadata, include_page_count, include_images } = parsedArgs;
@@ -147,11 +149,11 @@ export const handleReadPdfFunc = async (args) => {
                     });
                 }
                 else if (item.type === 'image' && item.imageData) {
-                    // Add image content part
+                    // Add image content part (all images are now encoded as PNG)
                     content.push({
                         type: 'image',
                         data: item.imageData.data,
-                        mimeType: item.imageData.format === 'rgba' ? 'image/png' : 'image/jpeg',
+                        mimeType: 'image/png',
                     });
                 }
             }

package/dist/index.js

@@ -11,7 +11,7 @@ import { allToolDefinitions } from './handlers/index.js';
 // --- Server Setup ---
 const server = new Server({
     name: 'pdf-reader-mcp',
-    version: '1.2.0',
+    version: '1.3.0',
     description: 'MCP Server for reading PDF files and extracting text, metadata, images, and page information.',
 }, {
     capabilities: { tools: {} },

package/dist/pdf/extractor.js

@@ -1,5 +1,42 @@
 // 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
  */
@@ -68,6 +105,7 @@ export const extractPageTexts = async (pdfDocument, pagesToProcess, sourceDescri
  */
 const extractImagesFromPage = async (page, pageNum) => {
     const images = [];
+    /* c8 ignore next */
     try {
         const operatorList = await page.getOperatorList();
         // Find all image painting operations
@@ -78,7 +116,7 @@ const extractImagesFromPage = async (page, pageNum) => {
                 imageIndices.push(i);
             }
         }
-        // Extract each image using Promise-based approach
+        // 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) {
@@ -86,30 +124,75 @@ const extractImagesFromPage = async (page, pageNum) => {
                 return;
             }
             const imageName = argsArray[0];
-            // Use callback-based get() as images may not be resolved yet
-            page.objs.get(imageName, (imageData) => {
+            // Helper to process image data
+            const processImageData = (imageData) => {
                 if (!imageData || typeof imageData !== 'object') {
-                    resolve(null);
-                    return;
+                    return null;
                 }
                 const img = imageData;
                 if (!img.data || !img.width || !img.height) {
-                    resolve(null);
-                    return;
+                    return null;
                 }
-                // Determine image format based on kind
-                // kind === 1 = grayscale, 2 = RGB, 3 = RGBA
+                // 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';
-                // Convert Uint8Array to base64
-                const base64 = Buffer.from(img.data).toString('base64');
-                resolve({
+                // 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: base64,
-                });
+                    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);
@@ -196,7 +279,7 @@ export const extractPageContent = async (pdfDocument, pageNum, includeImages, so
                     imageIndices.push(i);
                 }
             }
-            // Extract each image with its Y-coordinate
+            // 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) {
@@ -205,32 +288,29 @@ export const extractPageContent = async (pdfDocument, pageNum, includeImages, so
                 }
                 const imageName = argsArray[0];
                 // Get transform matrix from the args (if available)
-                // The transform is typically in argsArray[1] for some ops
                 let yPosition = 0;
                 if (argsArray.length > 1 && Array.isArray(argsArray[1])) {
                     const transform = argsArray[1];
-                    // transform[5] is the Y coordinate
                     const yCoord = transform[5];
                     if (yCoord !== undefined) {
                         yPosition = Math.round(yCoord);
                     }
                 }
-                // Use callback-based get() as images may not be resolved yet
-                page.objs.get(imageName, (imageData) => {
+                // Helper to process image data
+                const processImageData = (imageData) => {
                     if (!imageData || typeof imageData !== 'object') {
-                        resolve(null);
-                        return;
+                        return null;
                     }
                     const img = imageData;
                     if (!img.data || !img.width || !img.height) {
-                        resolve(null);
-                        return;
+                        return null;
                     }
-                    // Determine image format based on kind
+                    // 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';
-                    // Convert Uint8Array to base64
-                    const base64 = Buffer.from(img.data).toString('base64');
-                    resolve({
+                    // Encode raw pixel data to PNG format
+                    const pngBase64 = encodePixelsToPNG(img.data, img.width, img.height, channels);
+                    return {
                         type: 'image',
                         yPosition,
                         imageData: {
@@ -239,9 +319,58 @@ export const extractPageContent = async (pdfDocument, pageNum, includeImages, so
                             width: img.width,
                             height: img.height,
                             format,
-                            data: base64,
+                            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);

package/dist/pdf/parser.js

@@ -7,10 +7,9 @@ const MAX_RANGE_SIZE = 10000; // Prevent infinite loops for open ranges
 const parseRangePart = (part, pages) => {
     const trimmedPart = part.trim();
     if (trimmedPart.includes('-')) {
-        const [startStr, endStr] = trimmedPart.split('-');
-        if (startStr === undefined) {
-            throw new Error(`Invalid page range format: ${trimmedPart}`);
-        }
+        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) {
@@ -43,6 +42,9 @@ export const parsePageRanges = (ranges) => {
     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.');
     }

package/dist/schemas/readPdf.js

@@ -14,7 +14,11 @@ export const pageSpecifierSchema = z.union([
 // Schema for a single PDF source (path or URL)
 export const pdfSourceSchema = z
     .object({
-    path: z.string().min(1).optional().describe('Relative path to the local PDF file.'),
+    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()

package/dist/utils/pathUtils.js

@@ -6,10 +6,9 @@ import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 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 relative path against the project root,
- * ensuring it stays within the project boundaries.
- * Throws McpError on invalid input, absolute paths, or path traversal.
- * @param userPath The relative path provided by the user.
+ * 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) => {
@@ -17,14 +16,10 @@ export const resolvePath = (userPath) => {
         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)) {
-        throw new McpError(ErrorCode.InvalidParams, 'Absolute paths are not allowed.');
+        return normalizedUserPath;
     }
-    // Resolve against the calculated PROJECT_ROOT
-    const resolved = path.resolve(PROJECT_ROOT, normalizedUserPath);
-    // Security check: Ensure the resolved path is still within the project root
-    if (!resolved.startsWith(PROJECT_ROOT)) {
-        throw new McpError(ErrorCode.InvalidRequest, 'Path traversal detected. Access denied.');
-    }
-    return resolved;
+    // If relative path, resolve against the PROJECT_ROOT (cwd)
+    return path.resolve(PROJECT_ROOT, normalizedUserPath);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/pdf-reader-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "An MCP server providing tools to read PDF files.",
   "type": "module",
   "bin": {
@@ -39,20 +39,48 @@
     "agent",
     "tool"
   ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:cov": "vitest run --coverage --reporter=junit --outputFile=test-report.junit.xml",
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --write .",
+    "format": "biome format --write .",
+    "check-format": "biome format .",
+    "check": "biome check .",
+    "check:fix": "biome check --write .",
+    "validate": "npm run check && npm run test",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "benchmark": "vitest bench",
+    "clean": "rm -rf dist coverage",
+    "docs:api": "typedoc --entryPoints src/index.ts --tsconfig tsconfig.json --plugin typedoc-plugin-markdown --out docs/api --readme none",
+    "prepublishOnly": "pnpm run clean && pnpm run build",
+    "release": "standard-version",
+    "prepare": "husky"
+  },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.20.2",
+    "@modelcontextprotocol/sdk": "^1.21.0",
     "glob": "^11.0.1",
     "pdfjs-dist": "^5.4.296",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.5"
+    "pngjs": "^7.0.0",
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.2",
-    "@commitlint/cli": "^19.8.0",
-    "@commitlint/config-conventional": "^19.8.0",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
     "@types/glob": "^8.1.0",
     "@types/node": "^24.0.7",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@types/pngjs": "^6.0.5",
+    "@vitest/coverage-v8": "^4.0.7",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.6",
     "standard-version": "^9.5.0",
@@ -60,7 +88,7 @@
     "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "^5.8.3",
     "vitepress": "^1.6.3",
-    "vitest": "^3.1.1",
+    "vitest": "^4.0.7",
     "vue": "^3.5.13"
   },
   "commitlint": {
@@ -72,29 +100,5 @@
     "*.{ts,tsx,js,cjs,json}": [
       "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
     ]
-  },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
-    "test": "vitest run",
-    "test:watch": "vitest watch",
-    "test:cov": "vitest run --coverage --reporter=junit --outputFile=test-report.junit.xml",
-    "lint": "biome lint .",
-    "lint:fix": "biome lint --write .",
-    "format": "biome format --write .",
-    "check-format": "biome format .",
-    "check": "biome check .",
-    "check:fix": "biome check --write .",
-    "validate": "npm run check && npm run test",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs",
-    "start": "node dist/index.js",
-    "typecheck": "tsc --noEmit",
-    "benchmark": "vitest bench",
-    "clean": "rm -rf dist coverage",
-    "docs:api": "typedoc --entryPoints src/index.ts --tsconfig tsconfig.json --plugin typedoc-plugin-markdown --out docs/api --readme none",
-    "release": "standard-version"
   }
-}
+}