@wonderwhy-er/desktop-commander 0.2.23 → 0.2.25

package/dist/tools/improved-process-tools.d.ts

@@ -5,8 +5,8 @@ import { ServerResult } from '../types.js';
  */
 export declare function startProcess(args: unknown): Promise<ServerResult>;
 /**
- * Read output from a running process (renamed from read_output)
- * Includes early detection of process waiting for input
+ * Read output from a running process with file-like pagination
+ * Supports offset/length parameters for controlled reading
  */
 export declare function readProcessOutput(args: unknown): Promise<ServerResult>;
 /**

package/dist/tools/improved-process-tools.js

@@ -5,6 +5,75 @@ import { capture } from "../utils/capture.js";
 import { analyzeProcessState, cleanProcessOutput, formatProcessStateMessage } from '../utils/process-detection.js';
 import * as os from 'os';
 import { configManager } from '../config-manager.js';
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory where the MCP is installed (for ES module imports)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const mcpRoot = path.resolve(__dirname, '..', '..');
+// Track virtual Node sessions (PIDs that are actually Node fallback sessions)
+const virtualNodeSessions = new Map();
+let virtualPidCounter = -1000; // Use negative PIDs for virtual sessions
+/**
+ * Execute Node.js code via temp file (fallback when Python unavailable)
+ * Creates temp .mjs file in MCP directory for ES module import access
+ */
+async function executeNodeCode(code, timeout_ms = 30000) {
+    const tempFile = path.join(mcpRoot, `.mcp-exec-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
+    try {
+        await fs.writeFile(tempFile, code, 'utf8');
+        const result = await new Promise((resolve) => {
+            const proc = spawn(process.execPath, [tempFile], {
+                cwd: mcpRoot,
+                timeout: timeout_ms
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (exitCode) => {
+                resolve({ stdout, stderr, exitCode: exitCode ?? 1 });
+            });
+            proc.on('error', (err) => {
+                resolve({ stdout, stderr: stderr + '\n' + err.message, exitCode: 1 });
+            });
+        });
+        // Clean up temp file
+        await fs.unlink(tempFile).catch(() => { });
+        if (result.exitCode !== 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Execution failed (exit code ${result.exitCode}):\n${result.stderr}\n${result.stdout}`
+                    }],
+                isError: true
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: result.stdout || '(no output)'
+                }]
+        };
+    }
+    catch (error) {
+        // Clean up temp file on error
+        await fs.unlink(tempFile).catch(() => { });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to execute Node.js code: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}
 /**
  * Start a new process (renamed from execute_command)
  * Includes early detection of process waiting for input
@@ -37,6 +106,28 @@ export async function startProcess(args) {
             isError: true,
         };
     }
+    const commandToRun = parsed.data.command;
+    // Handle node:local - runs Node.js code directly on MCP server
+    if (commandToRun.trim() === 'node:local') {
+        const virtualPid = virtualPidCounter--;
+        virtualNodeSessions.set(virtualPid, { timeout_ms: parsed.data.timeout_ms || 30000 });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Node.js session started with PID ${virtualPid} (MCP server execution)
+
+   IMPORTANT: Each interact_with_process call runs as a FRESH script.
+   State is NOT preserved between calls. Include ALL code in ONE call:
+   - imports, file reading, processing, and output together.
+
+   Available libraries:
+   - ExcelJS for Excel files: import ExcelJS from 'exceljs'
+   - All Node.js built-ins: fs, path, http, crypto, etc.
+
+🔄 Ready for code - send complete self-contained script via interact_with_process.`
+                }],
+        };
+    }
     let shellUsed = parsed.data.shell;
     if (!shellUsed) {
         const config = await configManager.getConfig();
@@ -56,7 +147,7 @@ export async function startProcess(args) {
             }
         }
     }
-    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false);
+    const result = await terminalManager.executeCommand(commandToRun, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false);
     if (result.pid === -1) {
         return {
             content: [{ type: "text", text: result.output }],
@@ -110,8 +201,8 @@ function formatTimingInfo(timing) {
     return msg;
 }
 /**
- * Read output from a running process (renamed from read_output)
- * Includes early detection of process waiting for input
+ * Read output from a running process with file-like pagination
+ * Supports offset/length parameters for controlled reading
  */
 export async function readProcessOutput(args) {
     const parsed = ReadProcessOutputArgsSchema.safeParse(args);
@@ -121,229 +212,113 @@ export async function readProcessOutput(args) {
             isError: true,
         };
     }
-    const { pid, timeout_ms = 5000, verbose_timing = false } = parsed.data;
-    const session = terminalManager.getSession(pid);
-    if (!session) {
-        // Check if this is a completed session
-        const completedOutput = terminalManager.getNewOutput(pid);
-        if (completedOutput) {
-            return {
-                content: [{
-                        type: "text",
-                        text: completedOutput
-                    }],
-            };
-        }
-        // Neither active nor completed session found
-        return {
-            content: [{ type: "text", text: `No session found for PID ${pid}` }],
-            isError: true,
-        };
-    }
-    let output = "";
-    let timeoutReached = false;
-    let earlyExit = false;
-    let processState;
+    // Get default line limit from config
+    const config = await configManager.getConfig();
+    const defaultLength = config.fileReadLineLimit ?? 1000;
+    const { pid, timeout_ms = 5000, offset = 0, // 0 = from last read, positive = absolute, negative = tail
+    length = defaultLength, // Default from config, same as file reading
+    verbose_timing = false } = parsed.data;
     // Timing telemetry
     const startTime = Date.now();
-    let firstOutputTime;
-    let lastOutputTime;
-    const outputEvents = [];
-    let exitReason = 'timeout';
-    try {
-        const outputPromise = new Promise((resolve) => {
-            const initialOutput = terminalManager.getNewOutput(pid);
-            if (initialOutput && initialOutput.length > 0) {
-                const now = Date.now();
-                if (!firstOutputTime)
-                    firstOutputTime = now;
-                lastOutputTime = now;
-                if (verbose_timing) {
-                    outputEvents.push({
-                        timestamp: now,
-                        deltaMs: now - startTime,
-                        source: 'initial_poll',
-                        length: initialOutput.length,
-                        snippet: initialOutput.slice(0, 50).replace(/\n/g, '\\n')
-                    });
-                }
-                // Immediate check on existing output
-                const state = analyzeProcessState(initialOutput, pid);
-                if (state.isWaitingForInput) {
-                    earlyExit = true;
-                    processState = state;
-                    exitReason = 'early_exit_periodic_check';
-                }
-                resolve(initialOutput);
-                return;
-            }
-            let resolved = false;
-            let interval = null;
-            let timeout = null;
-            // Quick prompt patterns for immediate detection
-            const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
-            const cleanup = () => {
-                if (interval)
-                    clearInterval(interval);
-                if (timeout)
-                    clearTimeout(timeout);
-            };
-            let resolveOnce = (value, isTimeout = false) => {
-                if (resolved)
+    // For active sessions with no new output yet, optionally wait for output
+    const session = terminalManager.getSession(pid);
+    if (session && offset === 0) {
+        // Wait for new output to arrive (only for "new output" reads, not absolute/tail)
+        const waitForOutput = () => {
+            return new Promise((resolve) => {
+                // Check if there's already new output
+                const currentLines = terminalManager.getOutputLineCount(pid) || 0;
+                if (currentLines > session.lastReadIndex) {
+                    resolve();
                     return;
-                resolved = true;
-                cleanup();
-                timeoutReached = isTimeout;
-                if (isTimeout)
-                    exitReason = 'timeout';
-                resolve(value);
-            };
-            // Monitor for new output with immediate detection
-            const session = terminalManager.getSession(pid);
-            if (session && session.process && session.process.stdout && session.process.stderr) {
-                const immediateDetector = (data, source) => {
-                    const text = data.toString();
-                    const now = Date.now();
-                    if (!firstOutputTime)
-                        firstOutputTime = now;
-                    lastOutputTime = now;
-                    if (verbose_timing) {
-                        outputEvents.push({
-                            timestamp: now,
-                            deltaMs: now - startTime,
-                            source,
-                            length: text.length,
-                            snippet: text.slice(0, 50).replace(/\n/g, '\\n')
-                        });
-                    }
-                    // Immediate check for obvious prompts
-                    if (quickPromptPatterns.test(text)) {
-                        const newOutput = terminalManager.getNewOutput(pid) || text;
-                        const state = analyzeProcessState(output + newOutput, pid);
-                        if (state.isWaitingForInput) {
-                            earlyExit = true;
-                            processState = state;
-                            exitReason = 'early_exit_quick_pattern';
-                            if (verbose_timing && outputEvents.length > 0) {
-                                outputEvents[outputEvents.length - 1].matchedPattern = 'quick_pattern';
-                            }
-                            resolveOnce(newOutput);
-                            return;
-                        }
-                    }
-                };
-                const stdoutDetector = (data) => immediateDetector(data, 'stdout');
-                const stderrDetector = (data) => immediateDetector(data, 'stderr');
-                session.process.stdout.on('data', stdoutDetector);
-                session.process.stderr.on('data', stderrDetector);
-                // Cleanup immediate detectors when done
-                const originalResolveOnce = resolveOnce;
-                const cleanupDetectors = () => {
-                    if (session.process.stdout) {
-                        session.process.stdout.off('data', stdoutDetector);
-                    }
-                    if (session.process.stderr) {
-                        session.process.stderr.off('data', stderrDetector);
-                    }
-                };
-                // Override resolveOnce to include cleanup
-                const resolveOnceWithCleanup = (value, isTimeout = false) => {
-                    cleanupDetectors();
-                    originalResolveOnce(value, isTimeout);
+                }
+                let resolved = false;
+                let interval = null;
+                let timeout = null;
+                const cleanup = () => {
+                    if (interval)
+                        clearInterval(interval);
+                    if (timeout)
+                        clearTimeout(timeout);
                 };
-                // Replace the local resolveOnce reference
-                resolveOnce = resolveOnceWithCleanup;
-            }
-            interval = setInterval(() => {
-                const newOutput = terminalManager.getNewOutput(pid);
-                if (newOutput && newOutput.length > 0) {
-                    const now = Date.now();
-                    if (!firstOutputTime)
-                        firstOutputTime = now;
-                    lastOutputTime = now;
-                    if (verbose_timing) {
-                        outputEvents.push({
-                            timestamp: now,
-                            deltaMs: now - startTime,
-                            source: 'periodic_poll',
-                            length: newOutput.length,
-                            snippet: newOutput.slice(0, 50).replace(/\n/g, '\\n')
-                        });
-                    }
-                    const currentOutput = output + newOutput;
-                    const state = analyzeProcessState(currentOutput, pid);
-                    // Early exit if process is clearly waiting for input
-                    if (state.isWaitingForInput) {
-                        earlyExit = true;
-                        processState = state;
-                        exitReason = 'early_exit_periodic_check';
-                        if (verbose_timing && outputEvents.length > 0) {
-                            outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
-                        }
-                        resolveOnce(newOutput);
-                        return;
-                    }
-                    output = currentOutput;
-                    // Continue collecting if still running
-                    if (!state.isFinished) {
+                const resolveOnce = () => {
+                    if (resolved)
                         return;
+                    resolved = true;
+                    cleanup();
+                    resolve();
+                };
+                // Poll for new output
+                interval = setInterval(() => {
+                    const newLineCount = terminalManager.getOutputLineCount(pid) || 0;
+                    if (newLineCount > session.lastReadIndex) {
+                        resolveOnce();
                     }
-                    // Process finished
-                    processState = state;
-                    exitReason = 'process_finished';
-                    resolveOnce(newOutput);
-                }
-            }, 50); // Check every 50ms for faster response
-            timeout = setTimeout(() => {
-                const finalOutput = terminalManager.getNewOutput(pid) || "";
-                resolveOnce(finalOutput, true);
-            }, timeout_ms);
-        });
-        const newOutput = await outputPromise;
-        output += newOutput;
-        // Analyze final state if not already done
-        if (!processState) {
-            processState = analyzeProcessState(output, pid);
-        }
+                }, 50);
+                // Timeout
+                timeout = setTimeout(() => {
+                    resolveOnce();
+                }, timeout_ms);
+            });
+        };
+        await waitForOutput();
     }
-    catch (error) {
+    // Read output with pagination
+    const result = terminalManager.readOutputPaginated(pid, offset, length);
+    if (!result) {
         return {
-            content: [{ type: "text", text: `Error reading output: ${error}` }],
+            content: [{ type: "text", text: `No session found for PID ${pid}` }],
             isError: true,
         };
     }
-    // Format response based on what we detected
+    // Join lines back into string
+    const output = result.lines.join('\n');
+    // Generate status message similar to file reading
     let statusMessage = '';
-    if (earlyExit && processState?.isWaitingForInput) {
-        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+    if (offset < 0) {
+        // Tail read - match file reading format for consistency
+        statusMessage = `[Reading last ${result.readCount} lines (total: ${result.totalLines} lines)]`;
     }
-    else if (processState?.isFinished) {
-        statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+    else if (offset === 0) {
+        // "New output" read
+        if (result.remaining > 0) {
+            statusMessage = `[Reading ${result.readCount} new lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
+        }
+        else {
+            statusMessage = `[Reading ${result.readCount} new lines (total: ${result.totalLines} lines)]`;
+        }
     }
-    else if (timeoutReached) {
-        statusMessage = '\n⏱️ Timeout reached - process may still be running';
+    else {
+        // Absolute position read
+        statusMessage = `[Reading ${result.readCount} lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
+    }
+    // Add process state info
+    let processStateMessage = '';
+    if (result.isComplete) {
+        const runtimeStr = result.runtimeMs !== undefined
+            ? ` (runtime: ${(result.runtimeMs / 1000).toFixed(2)}s)`
+            : '';
+        processStateMessage = `\n✅ Process completed with exit code ${result.exitCode}${runtimeStr}`;
+    }
+    else if (session) {
+        // Analyze state for running processes
+        const fullOutput = session.outputLines.join('\n');
+        const processState = analyzeProcessState(fullOutput, pid);
+        if (processState.isWaitingForInput) {
+            processStateMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+        }
     }
     // Add timing information if requested
     let timingMessage = '';
     if (verbose_timing) {
         const endTime = Date.now();
-        const timingInfo = {
-            startTime,
-            endTime,
-            totalDurationMs: endTime - startTime,
-            exitReason,
-            firstOutputTime,
-            lastOutputTime,
-            timeToFirstOutputMs: firstOutputTime ? firstOutputTime - startTime : undefined,
-            outputEvents: outputEvents.length > 0 ? outputEvents : undefined
-        };
-        timingMessage = formatTimingInfo(timingInfo);
+        timingMessage = `\n\n📊 Timing: ${endTime - startTime}ms`;
     }
-    const responseText = output || 'No new output available';
+    const responseText = output || '(No output in requested range)';
     return {
         content: [{
                 type: "text",
-                text: `${responseText}${statusMessage}${timingMessage}`
+                text: `${statusMessage}\n\n${responseText}${processStateMessage}${timingMessage}`
             }],
     };
 }
@@ -363,6 +338,21 @@ export async function interactWithProcess(args) {
         };
     }
     const { pid, input, timeout_ms = 8000, wait_for_prompt = true, verbose_timing = false } = parsed.data;
+    // Get config for output line limit
+    const config = await configManager.getConfig();
+    const maxOutputLines = config.fileReadLineLimit ?? 1000;
+    // Check if this is a virtual Node session (node:local)
+    if (virtualNodeSessions.has(pid)) {
+        const session = virtualNodeSessions.get(pid);
+        capture('server_interact_with_process_node_fallback', {
+            pid: pid,
+            inputLength: input.length
+        });
+        // Execute code via temp file approach
+        // Respect per-call timeout if provided, otherwise use session default
+        const effectiveTimeout = timeout_ms ?? session.timeout_ms;
+        return executeNodeCode(input, effectiveTimeout);
+    }
     // Timing telemetry
     const startTime = Date.now();
     let firstOutputTime;
@@ -374,6 +364,9 @@ export async function interactWithProcess(args) {
             pid: pid,
             inputLength: input.length
         });
+        // Capture output snapshot BEFORE sending input
+        // This handles REPLs where output is appended to the prompt line
+        const outputSnapshot = terminalManager.captureOutputSnapshot(pid);
         const success = terminalManager.sendInputToProcess(pid, input);
         if (!success) {
             return {
@@ -419,6 +412,7 @@ export async function interactWithProcess(args) {
                 const pollIntervalMs = 50; // Poll every 50ms for faster response
                 const maxAttempts = Math.ceil(timeout_ms / pollIntervalMs);
                 let interval = null;
+                let lastOutputLength = 0; // Track output length to detect new output
                 let resolveOnce = () => {
                     if (resolved)
                         return;
@@ -431,8 +425,11 @@ export async function interactWithProcess(args) {
                 interval = setInterval(() => {
                     if (resolved)
                         return;
-                    const newOutput = terminalManager.getNewOutput(pid);
-                    if (newOutput && newOutput.length > 0) {
+                    // Use snapshot-based reading to handle REPL prompt line appending
+                    const newOutput = outputSnapshot
+                        ? terminalManager.getOutputSinceSnapshot(pid, outputSnapshot)
+                        : terminalManager.getNewOutput(pid);
+                    if (newOutput && newOutput.length > lastOutputLength) {
                         const now = Date.now();
                         if (!firstOutputTime)
                             firstOutputTime = now;
@@ -442,11 +439,12 @@ export async function interactWithProcess(args) {
                                 timestamp: now,
                                 deltaMs: now - startTime,
                                 source: 'periodic_poll',
-                                length: newOutput.length,
-                                snippet: newOutput.slice(0, 50).replace(/\n/g, '\\n')
+                                length: newOutput.length - lastOutputLength,
+                                snippet: newOutput.slice(lastOutputLength, lastOutputLength + 50).replace(/\n/g, '\\n')
                             });
                         }
-                        output += newOutput;
+                        output = newOutput; // Replace with full output since snapshot
+                        lastOutputLength = newOutput.length;
                         // Analyze current state
                         processState = analyzeProcessState(output, pid);
                         // Exit early if we detect the process is waiting for input
@@ -476,8 +474,17 @@ export async function interactWithProcess(args) {
         };
         await waitForResponse();
         // Clean and format output
-        const cleanOutput = cleanProcessOutput(output, input);
+        let cleanOutput = cleanProcessOutput(output, input);
         const timeoutReached = !earlyExit && !processState?.isFinished && !processState?.isWaitingForInput;
+        // Apply output line limit to prevent context overflow
+        let truncationMessage = '';
+        const outputLines = cleanOutput.split('\n');
+        if (outputLines.length > maxOutputLines) {
+            const truncatedLines = outputLines.slice(0, maxOutputLines);
+            cleanOutput = truncatedLines.join('\n');
+            const remainingLines = outputLines.length - maxOutputLines;
+            truncationMessage = `\n\n⚠️ Output truncated: showing ${maxOutputLines} of ${outputLines.length} lines (${remainingLines} hidden). Use read_process_output with offset/length for full output.`;
+        }
         // Determine final state
         if (!processState) {
             processState = analyzeProcessState(output, pid);
@@ -527,6 +534,9 @@ export async function interactWithProcess(args) {
         if (statusMessage) {
             responseText += `\n\n${statusMessage}`;
         }
+        if (truncationMessage) {
+            responseText += truncationMessage;
+        }
         if (timingMessage) {
             responseText += timingMessage;
         }
@@ -559,13 +569,24 @@ export async function forceTerminate(args) {
             isError: true,
         };
     }
-    const success = terminalManager.forceTerminate(parsed.data.pid);
+    const pid = parsed.data.pid;
+    // Handle virtual Node.js sessions (node:local)
+    if (virtualNodeSessions.has(pid)) {
+        virtualNodeSessions.delete(pid);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Cleared virtual Node.js session ${pid}`
+                }],
+        };
+    }
+    const success = terminalManager.forceTerminate(pid);
     return {
         content: [{
                 type: "text",
                 text: success
-                    ? `Successfully initiated termination of session ${parsed.data.pid}`
-                    : `No active session found for PID ${parsed.data.pid}`
+                    ? `Successfully initiated termination of session ${pid}`
+                    : `No active session found for PID ${pid}`
             }],
     };
 }
@@ -574,12 +595,21 @@ export async function forceTerminate(args) {
  */
 export async function listSessions() {
     const sessions = terminalManager.listActiveSessions();
+    // Include virtual Node.js sessions
+    const virtualSessions = Array.from(virtualNodeSessions.entries()).map(([pid, session]) => ({
+        pid,
+        type: 'node:local',
+        timeout_ms: session.timeout_ms
+    }));
+    const realSessionsText = sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`);
+    const virtualSessionsText = virtualSessions.map(s => `PID: ${s.pid} (node:local), Timeout: ${s.timeout_ms}ms`);
+    const allSessions = [...realSessionsText, ...virtualSessionsText];
     return {
         content: [{
                 type: "text",
-                text: sessions.length === 0
+                text: allSessions.length === 0
                     ? 'No active sessions'
-                    : sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n')
+                    : allSessions.join('\n')
             }],
     };
 }

package/dist/tools/mime-types.d.ts

@@ -1,2 +1,3 @@
 export declare function getMimeType(filePath: string): string;
+export declare function isPdfFile(mimeType: string): boolean;
 export declare function isImageFile(mimeType: string): boolean;

package/dist/tools/mime-types.js

@@ -1,6 +1,9 @@
 // Simple MIME type detection based on file extension
 export function getMimeType(filePath) {
     const extension = filePath.toLowerCase().split('.').pop() || '';
+    if (extension === "pdf") {
+        return "application/pdf";
+    }
     // Image types - only the formats we can display
     const imageTypes = {
         'png': 'image/png',
@@ -16,6 +19,10 @@ export function getMimeType(filePath) {
     // Default to text/plain for all other files
     return 'text/plain';
 }
+export function isPdfFile(mimeType) {
+    const [baseType] = mimeType.toLowerCase().split(';');
+    return baseType.trim() === 'application/pdf';
+}
 export function isImageFile(mimeType) {
     return mimeType.startsWith('image/');
 }

package/dist/tools/pdf/extract-images.d.ts

@@ -0,0 +1,34 @@
+export interface ImageInfo {
+    /** Object ID within PDF */
+    objId: number;
+    width: number;
+    height: number;
+    /** Raw image data as base64 */
+    data: string;
+    /** MIME type of the image */
+    mimeType: string;
+    /** Original size in bytes before compression */
+    originalSize?: number;
+    /** Compressed size in bytes */
+    compressedSize?: number;
+}
+export interface PageImages {
+    pageNumber: number;
+    images: ImageInfo[];
+}
+export interface ImageCompressionOptions {
+    /** Output format: 'jpeg' | 'webp' */
+    format?: 'jpeg' | 'webp';
+    /** Quality for lossy formats (0-100, default 85) */
+    quality?: number;
+    /** Maximum dimension to resize to (maintains aspect ratio) */
+    maxDimension?: number;
+}
+/**
+ * Optimized image extraction from PDF using unpdf's built-in extractImages method
+ * @param pdfBuffer PDF file as Uint8Array
+ * @param pageNumbers Optional array of specific page numbers to process
+ * @param compressionOptions Image compression settings
+ * @returns Record of page numbers to extracted images
+ */
+export declare function extractImagesFromPdf(pdfBuffer: Uint8Array, pageNumbers?: number[], compressionOptions?: ImageCompressionOptions): Promise<Record<number, ImageInfo[]>>;