@sylphx/pdf-reader-mcp 1.3.2 → 1.4.0

package/README.md

@@ -93,35 +93,63 @@ Real-world performance from production testing:
 
 ## 📦 Installation
 
+### VS Code
+
+Install with one click using the VS Code extension buttons:
+
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-007ACC?style=for-the-badge&logo=visual-studio-code)](https://insiders.vscode.dev/redirect?url=vscode://ms-vscode.vscode-mcp/install?mcpId=sylphx-pdf-reader-mcp)
+[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=for-the-badge&logo=visual-studio-code)](https://insiders.vscode.dev/redirect?url=vscode-insiders://ms-vscode.vscode-mcp/install?mcpId=sylphx-pdf-reader-mcp)
+
+Or via CLI:
+
 ```bash
-# Quick start - zero installation
-npx @sylphx/pdf-reader-mcp
+code --add-mcp '{"name":"pdf-reader","command":"npx","args":["@sylphx/pdf-reader-mcp"]}'
+```
 
-# Using pnpm (recommended)
-pnpm add @sylphx/pdf-reader-mcp
+### Claude Code
 
-# Using npm
-npm install @sylphx/pdf-reader-mcp
+```bash
+claude mcp add pdf-reader -- npx @sylphx/pdf-reader-mcp
+```
 
-# Using yarn
-yarn add @sylphx/pdf-reader-mcp
+### Claude Desktop
 
-# For Claude Desktop (easiest)
-npx -y @smithery/cli install @sylphx/pdf-reader-mcp --client claude
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "pdf-reader": {
+      "command": "npx",
+      "args": ["@sylphx/pdf-reader-mcp"]
+    }
+  }
+}
 ```
 
----
+<details>
+<summary><strong>📍 Config file locations</strong></summary>
 
-## 🎯 Quick Start
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+</details>
+
+### Cursor
 
-### Configuration
+1. Open **Settings** → **MCP** → **Add new MCP Server**
+2. Select **Command** type
+3. Enter: `npx @sylphx/pdf-reader-mcp`
 
-Add to your MCP client (`claude_desktop_config.json`, Cursor, Cline):
+### Windsurf
+
+Add to your Windsurf MCP config:
 
 ```json
 {
   "mcpServers": {
-    "pdf-reader-mcp": {
+    "pdf-reader": {
       "command": "npx",
       "args": ["@sylphx/pdf-reader-mcp"]
     }
@@ -129,6 +157,49 @@ Add to your MCP client (`claude_desktop_config.json`, Cursor, Cline):
 }
 ```
 
+### Cline
+
+Add to Cline's MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "pdf-reader": {
+      "command": "npx",
+      "args": ["@sylphx/pdf-reader-mcp"]
+    }
+  }
+}
+```
+
+### Warp
+
+1. Go to **Settings** → **AI** → **Manage MCP Servers** → **Add**
+2. Or use the `/add-mcp` slash command with the standard config
+
+### Smithery (One-click)
+
+```bash
+npx -y @smithery/cli install @sylphx/pdf-reader-mcp --client claude
+```
+
+### Manual Installation
+
+```bash
+# Quick start - zero installation
+npx @sylphx/pdf-reader-mcp
+
+# Using bun (recommended)
+bun add @sylphx/pdf-reader-mcp
+
+# Using npm
+npm install @sylphx/pdf-reader-mcp
+```
+
+---
+
+## 🎯 Quick Start
+
 ### Basic Usage
 
 ```json
@@ -701,11 +772,22 @@ MIT © [Sylphx](https://sylphx.com)
 
 Built with:
 - [PDF.js](https://mozilla.github.io/pdf.js/) - Mozilla PDF engine
-- [MCP SDK](https://modelcontextprotocol.io) - Model Context Protocol
-- [Vitest](https://vitest.dev) - Fast testing framework
+- [Bun](https://bun.sh) - Fast JavaScript runtime
 
 Special thanks to the open source community ❤️
 
+## Powered by Sylphx
+
+This project uses the following [@sylphx](https://github.com/SylphxAI) packages:
+
+- [@sylphx/mcp-server-sdk](https://github.com/SylphxAI/mcp-server-sdk) - MCP server framework
+- [@sylphx/biome-config](https://github.com/SylphxAI/biome-config) - Biome configuration
+- [@sylphx/tsconfig](https://github.com/SylphxAI/tsconfig) - TypeScript configuration
+- [@sylphx/bump](https://github.com/SylphxAI/bump) - Version management
+- [@sylphx/doctor](https://github.com/SylphxAI/doctor) - Project health checker
+- [@sylphx/leaf](https://github.com/SylphxAI/leaf) - Documentation framework
+- [@sylphx/leaf-theme-default](https://github.com/SylphxAI/leaf-theme-default) - Documentation theme
+
 ---
 
 <p align="center">

package/dist/index.js

@@ -1,23 +1,94 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ErrorCode as ErrorCode5,
-  ListToolsRequestSchema,
-  McpError as McpError5
-} from "@modelcontextprotocol/sdk/types.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { createServer, stdio } from "@sylphx/mcp-server-sdk";
 
 // src/handlers/readPdf.ts
-import { ErrorCode as ErrorCode4, McpError as McpError4 } from "@modelcontextprotocol/sdk/types.js";
-import { z as z2 } from "zod";
+import { image, text, tool, toolError } from "@sylphx/mcp-server-sdk";
 
 // src/pdf/extractor.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
 import { PNG } from "pngjs";
+
+// src/utils/logger.ts
+class Logger {
+  prefix;
+  minLevel;
+  constructor(component, minLevel = 1 /* INFO */) {
+    this.prefix = `[PDF Reader MCP${component ? ` - ${component}` : ""}]`;
+    this.minLevel = minLevel;
+  }
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  debug(message, context) {
+    if (this.minLevel <= 0 /* DEBUG */) {
+      this.log("debug", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.minLevel <= 1 /* INFO */) {
+      this.log("info", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.minLevel <= 2 /* WARN */) {
+      this.log("warn", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.minLevel <= 3 /* ERROR */) {
+      this.log("error", message, context);
+    }
+  }
+  logWithContext(level, logMessage, structuredLog) {
+    if (level === "error") {
+      console.error(logMessage);
+      console.error(JSON.stringify(structuredLog));
+    } else if (level === "warn") {
+      console.warn(logMessage);
+      console.warn(JSON.stringify(structuredLog));
+    } else if (level === "info") {
+      console.info(logMessage);
+    } else {
+      console.log(logMessage);
+    }
+  }
+  logSimple(level, logMessage) {
+    if (level === "error") {
+      console.error(logMessage);
+    } else if (level === "warn") {
+      console.warn(logMessage);
+    } else if (level === "info") {
+      console.info(logMessage);
+    } else {
+      console.log(logMessage);
+    }
+  }
+  log(level, message, context) {
+    const logMessage = `${this.prefix} ${message}`;
+    if (context && Object.keys(context).length > 0) {
+      const timestamp = new Date().toISOString();
+      const structuredLog = {
+        timestamp,
+        level,
+        component: this.prefix,
+        message,
+        ...context
+      };
+      this.logWithContext(level, logMessage, structuredLog);
+    } else {
+      this.logSimple(level, logMessage);
+    }
+  }
+}
+var createLogger = (component, minLevel) => {
+  return new Logger(component, minLevel);
+};
+var logger = new Logger("", 2 /* WARN */);
+
+// src/pdf/extractor.ts
+var logger2 = createLogger("Extractor");
 var encodePixelsToPNG = (pixelData, width, height, channels) => {
   const png = new PNG({ width, height });
   if (channels === 4) {
@@ -44,6 +115,83 @@ var encodePixelsToPNG = (pixelData, width, height, channels) => {
   const pngBuffer = PNG.sync.write(png);
   return pngBuffer.toString("base64");
 };
+var processImageData = (imageData, pageNum, arrayIndex) => {
+  if (!imageData || typeof imageData !== "object") {
+    return null;
+  }
+  const img = imageData;
+  if (!img.data || !img.width || !img.height) {
+    return null;
+  }
+  const channels = img.kind === 1 ? 1 : img.kind === 3 ? 4 : 3;
+  const format = img.kind === 1 ? "grayscale" : img.kind === 3 ? "rgba" : "rgb";
+  const pngBase64 = encodePixelsToPNG(img.data, img.width, img.height, channels);
+  return {
+    page: pageNum,
+    index: arrayIndex,
+    width: img.width,
+    height: img.height,
+    format,
+    data: pngBase64
+  };
+};
+var retrieveImageData = async (page, imageName, pageNum) => {
+  if (imageName.startsWith("g_")) {
+    try {
+      const imageData = page.commonObjs.get(imageName);
+      if (imageData) {
+        return imageData;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger2.warn("Error getting image from commonObjs", { imageName, error: message });
+    }
+  }
+  try {
+    const imageData = page.objs.get(imageName);
+    if (imageData !== undefined) {
+      return imageData;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger2.warn("Sync image get failed, trying async", { imageName, error: message });
+  }
+  return new Promise((resolve) => {
+    let resolved = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    timeoutId = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        logger2.warn("Image extraction timeout", { imageName, pageNum });
+        resolve(null);
+      }
+    }, 1e4);
+    try {
+      page.objs.get(imageName, (imageData) => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          resolve(imageData);
+        }
+      });
+    } catch (error) {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        const message = error instanceof Error ? error.message : String(error);
+        logger2.warn("Error in async image get", { imageName, error: message });
+        resolve(null);
+      }
+    }
+  });
+};
 var extractMetadataAndPageCount = async (pdfDocument, includeMetadata, includePageCount) => {
   const output = {};
   if (includePageCount) {
@@ -69,7 +217,8 @@ var extractMetadataAndPageCount = async (pdfDocument, includeMetadata, includePa
         output.metadata = metadataRecord;
       }
     } catch (metaError) {
-      console.warn(`[PDF Reader MCP] Error extracting metadata: ${metaError instanceof Error ? metaError.message : String(metaError)}`);
+      const message = metaError instanceof Error ? metaError.message : String(metaError);
+      logger2.warn("Error extracting metadata", { error: message });
     }
   }
   return output;
@@ -118,11 +267,10 @@ var extractPageContent = async (pdfDocument, pageNum, includeImages, sourceDescr
           imageIndices.push(i);
         }
       }
-      const imagePromises = imageIndices.map((imgIndex, arrayIndex) => new Promise((resolve) => {
+      const imagePromises = imageIndices.map(async (imgIndex, arrayIndex) => {
         const argsArray = operatorList.argsArray[imgIndex];
         if (!argsArray || argsArray.length === 0) {
-          resolve(null);
-          return;
+          return null;
         }
         const imageName = argsArray[0];
         let yPosition = 0;
@@ -133,77 +281,28 @@ var extractPageContent = async (pdfDocument, pageNum, includeImages, sourceDescr
             yPosition = Math.round(yCoord);
           }
         }
-        const processImageData = (imageData) => {
-          if (!imageData || typeof imageData !== "object") {
-            return null;
-          }
-          const img = imageData;
-          if (!img.data || !img.width || !img.height) {
-            return null;
-          }
-          const channels = img.kind === 1 ? 1 : img.kind === 3 ? 4 : 3;
-          const format = img.kind === 1 ? "grayscale" : img.kind === 3 ? "rgba" : "rgb";
-          const pngBase64 = encodePixelsToPNG(img.data, img.width, img.height, channels);
+        const imageData = await retrieveImageData(page, imageName, pageNum);
+        const extractedImage = processImageData(imageData, pageNum, arrayIndex);
+        if (extractedImage) {
           return {
             type: "image",
             yPosition,
-            imageData: {
-              page: pageNum,
-              index: arrayIndex,
-              width: img.width,
-              height: img.height,
-              format,
-              data: pngBase64
-            }
+            imageData: extractedImage
           };
-        };
-        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 {
-          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}`);
         }
-        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);
-          }
-        }, 1e4);
-        page.objs.get(imageName, (imageData) => {
-          if (!resolved) {
-            resolved = true;
-            clearTimeout(timeout);
-            const result = processImageData(imageData);
-            resolve(result);
-          }
-        });
-      }));
+        return null;
+      });
       const resolvedImages = await Promise.all(imagePromises);
-      contentItems.push(...resolvedImages.filter((item) => item !== null));
+      const validImages = resolvedImages.filter((item) => item !== null);
+      contentItems.push(...validImages);
     }
   } 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}`);
+    logger2.warn("Error extracting page content", {
+      pageNum,
+      sourceDescription,
+      error: message
+    });
     return [
       {
         type: "text",
@@ -217,62 +316,82 @@ var extractPageContent = async (pdfDocument, pageNum, includeImages, sourceDescr
 
 // src/pdf/loader.ts
 import fs from "node:fs/promises";
-import { ErrorCode as ErrorCode2, McpError as McpError2 } from "@modelcontextprotocol/sdk/types.js";
 import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
 
+// src/utils/errors.ts
+class PdfError extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options?.cause ? { cause: options.cause } : undefined);
+    this.code = code;
+    this.name = "PdfError";
+  }
+}
+
 // src/utils/pathUtils.ts
+import os from "node:os";
 import path from "node:path";
-import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
 var PROJECT_ROOT = process.cwd();
+var ALLOWED_ROOTS = [PROJECT_ROOT, os.homedir()];
 var resolvePath = (userPath) => {
   if (typeof userPath !== "string") {
-    throw new McpError(ErrorCode.InvalidParams, "Path must be a string.");
+    throw new PdfError(-32602 /* InvalidParams */, "Path must be a string.");
   }
   const normalizedUserPath = path.normalize(userPath);
-  if (path.isAbsolute(normalizedUserPath)) {
-    return normalizedUserPath;
+  const resolvedPath = path.isAbsolute(normalizedUserPath) ? normalizedUserPath : path.resolve(PROJECT_ROOT, normalizedUserPath);
+  const isWithinAllowedRoot = ALLOWED_ROOTS.some((allowedRoot) => {
+    const relativePath = path.relative(allowedRoot, resolvedPath);
+    return relativePath !== "" && !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  });
+  if (!isWithinAllowedRoot) {
+    throw new PdfError(-32602 /* InvalidParams */, "Access denied: Path resolves outside allowed directories.");
   }
-  return path.resolve(PROJECT_ROOT, normalizedUserPath);
+  return resolvedPath;
 };
 
 // src/pdf/loader.ts
+var logger3 = createLogger("Loader");
+var MAX_PDF_SIZE = 100 * 1024 * 1024;
 var loadPdfDocument = async (source, sourceDescription) => {
   let pdfDataSource;
   try {
     if (source.path) {
       const safePath = resolvePath(source.path);
       const buffer = await fs.readFile(safePath);
+      if (buffer.length > MAX_PDF_SIZE) {
+        throw new PdfError(-32600 /* InvalidRequest */, `PDF file exceeds maximum size of ${MAX_PDF_SIZE} bytes (${(MAX_PDF_SIZE / 1024 / 1024).toFixed(0)}MB). File size: ${buffer.length} bytes.`);
+      }
       pdfDataSource = new Uint8Array(buffer);
     } else if (source.url) {
       pdfDataSource = { url: source.url };
     } else {
-      throw new McpError2(ErrorCode2.InvalidParams, `Source ${sourceDescription} missing 'path' or 'url'.`);
+      throw new PdfError(-32602 /* InvalidParams */, `Source ${sourceDescription} missing 'path' or 'url'.`);
     }
   } catch (err) {
-    if (err instanceof McpError2) {
+    if (err instanceof PdfError) {
       throw err;
     }
     const message = err instanceof Error ? err.message : String(err);
-    const errorCode = ErrorCode2.InvalidRequest;
+    const errorCode = -32600 /* InvalidRequest */;
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT" && source.path) {
-      throw new McpError2(errorCode, `File not found at '${source.path}'.`, {
+      throw new PdfError(errorCode, `File not found at '${source.path}'.`, {
         cause: err instanceof Error ? err : undefined
       });
     }
-    throw new McpError2(errorCode, `Failed to prepare PDF source ${sourceDescription}. Reason: ${message}`, { cause: err instanceof Error ? err : undefined });
+    throw new PdfError(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 McpError2(ErrorCode2.InvalidRequest, `Failed to load PDF document from ${sourceDescription}. Reason: ${message || "Unknown loading error"}`, { cause: err instanceof Error ? err : undefined });
+    logger3.error("PDF.js loading error", { sourceDescription, error: message });
+    throw new PdfError(-32600 /* InvalidRequest */, `Failed to load PDF document from ${sourceDescription}. Reason: ${message || "Unknown loading error"}`, { cause: err instanceof Error ? err : undefined });
   }
 };
 
 // src/pdf/parser.ts
-import { ErrorCode as ErrorCode3, McpError as McpError3 } from "@modelcontextprotocol/sdk/types.js";
+var logger4 = createLogger("Parser");
 var MAX_RANGE_SIZE = 1e4;
 var parseRangePart = (part, pages) => {
   const trimmedPart = part.trim();
@@ -290,7 +409,7 @@ var parseRangePart = (part, pages) => {
       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)}.`);
+      logger4.warn("Open-ended range truncated", { start, practicalEnd });
     }
   } else {
     const page = parseInt(trimmedPart, 10);
@@ -329,7 +448,7 @@ var getTargetPages = (sourcePages, sourceDescription) => {
     return uniquePages;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new McpError3(ErrorCode3.InvalidParams, `Invalid page specification for source ${sourceDescription}: ${message}`);
+    throw new PdfError(-32602 /* InvalidParams */, `Invalid page specification for source ${sourceDescription}: ${message}`);
   }
 };
 var determinePagesToProcess = (targetPages, totalPages, includeFullText) => {
@@ -369,13 +488,15 @@ var readPdfArgsSchema = z.object({
 }).strict();
 
 // src/handlers/readPdf.ts
+var logger5 = createLogger("ReadPdf");
 var processSingleSource = async (source, options) => {
   const sourceDescription = source.path ?? source.url ?? "unknown source";
   let individualResult = { source: sourceDescription, success: false };
+  let pdfDocument = null;
   try {
     const targetPages = getTargetPages(source.pages, sourceDescription);
     const { pages: _pages, ...loadArgs } = source;
-    const pdfDocument = await loadPdfDocument(loadArgs, sourceDescription);
+    pdfDocument = await loadPdfDocument(loadArgs, sourceDescription);
     const totalPages = pdfDocument.numPages;
     const metadataOutput = await extractMetadataAndPageCount(pdfDocument, options.includeMetadata, options.includePageCount);
     const output = { ...metadataOutput };
@@ -411,9 +532,7 @@ var processSingleSource = async (source, options) => {
     individualResult = { ...individualResult, data: output, success: true };
   } catch (error) {
     let errorMessage = `Failed to process PDF from ${sourceDescription}.`;
-    if (error instanceof McpError4) {
-      errorMessage = error.message;
-    } else if (error instanceof Error) {
+    if (error instanceof Error) {
       errorMessage += ` Reason: ${error.message}`;
     } else {
       errorMessage += ` Unknown error: ${JSON.stringify(error)}`;
@@ -421,27 +540,38 @@ var processSingleSource = async (source, options) => {
     individualResult.error = errorMessage;
     individualResult.success = false;
     individualResult.data = undefined;
+  } finally {
+    if (pdfDocument && typeof pdfDocument.destroy === "function") {
+      try {
+        await pdfDocument.destroy();
+      } catch (destroyError) {
+        const message = destroyError instanceof Error ? destroyError.message : String(destroyError);
+        logger5.warn("Error destroying PDF document", { sourceDescription, error: message });
+      }
+    }
   }
   return individualResult;
 };
-var handleReadPdfFunc = async (args) => {
-  let parsedArgs;
-  try {
-    parsedArgs = readPdfArgsSchema.parse(args);
-  } catch (error) {
-    if (error instanceof z2.ZodError) {
-      throw new McpError4(ErrorCode4.InvalidParams, `Invalid arguments: ${error.issues.map((e) => `${e.path.join(".")} (${e.message})`).join(", ")}`);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new McpError4(ErrorCode4.InvalidParams, `Argument validation failed: ${message}`);
-  }
-  const { sources, include_full_text, include_metadata, include_page_count, include_images } = parsedArgs;
-  const results = await Promise.all(sources.map((source) => processSingleSource(source, {
-    includeFullText: include_full_text,
-    includeMetadata: include_metadata,
-    includePageCount: include_page_count,
-    includeImages: include_images
-  })));
+var readPdf = tool().description("Reads content/metadata/images from one or more PDFs (local/URL). Each source can specify pages to extract.").input(readPdfArgsSchema).handler(async ({ input }) => {
+  const { sources, include_full_text, include_metadata, include_page_count, include_images } = input;
+  const MAX_CONCURRENT_SOURCES = 3;
+  const results = [];
+  const options = {
+    includeFullText: include_full_text ?? false,
+    includeMetadata: include_metadata ?? true,
+    includePageCount: include_page_count ?? true,
+    includeImages: include_images ?? false
+  };
+  for (let i = 0;i < sources.length; i += MAX_CONCURRENT_SOURCES) {
+    const batch = sources.slice(i, i + MAX_CONCURRENT_SOURCES);
+    const batchResults = await Promise.all(batch.map((source) => processSingleSource(source, options)));
+    results.push(...batchResults);
+  }
+  const allFailed = results.every((r) => !r.success);
+  if (allFailed) {
+    const errorMessages = results.map((r) => r.error).join("; ");
+    return toolError(`All PDF sources failed to process: ${errorMessages}`);
+  }
   const content = [];
   const resultsForJson = results.map((result) => {
     if (result.data) {
@@ -460,71 +590,33 @@ var handleReadPdfFunc = async (args) => {
     }
     return result;
   });
-  content.push({
-    type: "text",
-    text: JSON.stringify({ results: resultsForJson }, null, 2)
-  });
+  content.push(text(JSON.stringify({ results: resultsForJson }, null, 2)));
   for (const result of results) {
     if (!result.success || !result.data?.page_contents)
       continue;
     for (const pageContent of result.data.page_contents) {
       for (const item of pageContent.items) {
         if (item.type === "text" && item.textContent) {
-          content.push({
-            type: "text",
-            text: item.textContent
-          });
+          content.push(text(item.textContent));
         } else if (item.type === "image" && item.imageData) {
-          content.push({
-            type: "image",
-            data: item.imageData.data,
-            mimeType: "image/png"
-          });
+          content.push(image(item.imageData.data, "image/png"));
         }
       }
     }
   }
-  return { content };
-};
-var readPdfToolDefinition = {
-  name: "read_pdf",
-  description: "Reads content/metadata/images from one or more PDFs (local/URL). Each source can specify pages to extract.",
-  schema: readPdfArgsSchema,
-  handler: handleReadPdfFunc
-};
-
-// src/handlers/index.ts
-var allToolDefinitions = [readPdfToolDefinition];
+  return content;
+});
 
 // src/index.ts
-var server = new Server({
+var server = createServer({
   name: "pdf-reader-mcp",
   version: "1.3.0",
-  description: "MCP Server for reading PDF files and extracting text, metadata, images, and page information."
-}, {
-  capabilities: { tools: {} }
-});
-var generateInputSchema = (schema) => {
-  return zodToJsonSchema(schema, { target: "openApi3" });
-};
-server.setRequestHandler(ListToolsRequestSchema, () => {
-  const availableTools = allToolDefinitions.map((def) => ({
-    name: def.name,
-    description: def.description,
-    inputSchema: generateInputSchema(def.schema)
-  }));
-  return { tools: availableTools };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const toolDefinition = allToolDefinitions.find((def) => def.name === request.params.name);
-  if (!toolDefinition) {
-    throw new McpError5(ErrorCode5.MethodNotFound, `Unknown tool: ${request.params.name}`);
-  }
-  return toolDefinition.handler(request.params.arguments);
+  instructions: "MCP Server for reading PDF files and extracting text, metadata, images, and page information.",
+  tools: { read_pdf: readPdf },
+  transport: stdio()
 });
 async function main() {
-  const transport = new StdioServerTransport;
-  await server.connect(transport);
+  await server.start();
   if (process.env.DEBUG_MCP) {
     console.error("[PDF Reader MCP] Server running on stdio");
     console.error("[PDF Reader MCP] Project root:", process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/pdf-reader-mcp",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "An MCP server providing tools to read PDF files.",
   "type": "module",
   "bin": {
@@ -11,6 +11,12 @@
     "README.md",
     "LICENSE"
   ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -43,9 +49,9 @@
     "build": "bunup",
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
-    "test": "vitest run",
-    "test:watch": "vitest watch",
-    "test:cov": "vitest run --coverage",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:cov": "bun test --coverage",
     "lint": "biome lint .",
     "lint:fix": "biome lint --write .",
     "format": "biome format --write .",
@@ -53,58 +59,48 @@
     "check": "biome check .",
     "check:fix": "biome check --write .",
     "validate": "bun run check && bun run test",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs",
+    "docs:dev": "leaf dev docs",
+    "docs:build": "leaf build docs",
+    "docs:preview": "leaf preview docs",
     "start": "node dist/index.js",
     "typecheck": "tsc --noEmit",
-    "benchmark": "vitest bench",
+    "benchmark": "bun 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": "bun run clean && bun run build",
+    "prepublishOnly": "bunx @sylphx/doctor prepublish && bun run clean && bun run build",
     "release": "standard-version",
-    "prepare": "husky",
-    "changeset": "changeset",
-    "version-packages": "changeset version",
-    "release:new": "bun run build && changeset publish"
+    "prepare": "node_modules/.bin/lefthook install || true"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.21.0",
-    "glob": "^11.0.1",
-    "pdfjs-dist": "^5.4.296",
+    "@sylphx/mcp-server-sdk": "1.0.0",
+    "glob": "^11.1.0",
+    "pdfjs-dist": "^5.4.394",
     "pngjs": "^7.0.0",
-    "zod": "^3.25.76",
-    "zod-to-json-schema": "^3.24.6"
+    "zod": "4.2.0-canary.20251124T022609",
+    "zod-to-json-schema": "^3.25.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.2",
-    "@changesets/cli": "^2.29.7",
-    "@commitlint/cli": "^20.1.0",
-    "@commitlint/config-conventional": "^20.0.0",
+    "@biomejs/biome": "^2.3.8",
+    "@solidjs/router": "^0.15.4",
+    "@sylphx/biome-config": "^0.4.0",
+    "@sylphx/bump": "^0.12.1",
+    "@sylphx/doctor": "^1.23.3",
+    "@sylphx/leaf": "^1.0.0",
+    "@sylphx/leaf-theme-default": "^1.0.0",
+    "@sylphx/tsconfig": "^0.3.0",
     "@types/glob": "^8.1.0",
-    "@types/node": "^24.0.7",
+    "@types/node": "^24.10.1",
     "@types/pngjs": "^6.0.5",
-    "@vitest/coverage-v8": "^4.0.8",
     "bunup": "^0.16.10",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.6",
-    "standard-version": "^9.5.0",
-    "typedoc": "^0.28.2",
+    "lefthook": "^2.0.4",
+    "solid-js": "^1.9.10",
+    "typedoc": "^0.28.14",
     "typedoc-plugin-markdown": "^4.9.0",
-    "typescript": "^5.8.3",
-    "vitepress": "^1.6.3",
-    "vitest": "^4.0.7",
-    "vue": "^3.5.13"
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "lint-staged": {
-    "*.{ts,tsx,js,cjs,json}": [
-      "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
-    ]
+    "typescript": "^5.9.3",
+    "vite": "^7.2.4"
   },
-  "packageManager": "bun@1.3.1"
+  "packageManager": "bun@1.3.1",
+  "overrides": {
+    "js-yaml": "^4.1.0"
+  }
 }