@hcu-lab.me/mcp-device 1.0.9 → 1.0.12

package/dist/terminal-manager.js

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { randomUUID } from 'node:crypto';
 import path from 'path';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
@@ -102,6 +103,11 @@ export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.completedSessions = new Map();
+        this.runtimeGeneration = randomUUID();
+    }
+    processIdentity(pid) {
+        const session = this.sessions.get(pid) ?? this.completedSessions.get(pid);
+        return session ? { execution_id: session.executionId, runtime_generation: this.runtimeGeneration, pid } : undefined;
     }
     /**
      * Send input to a running process
@@ -129,6 +135,9 @@ export class TerminalManager {
         }
     }
     async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell, collectTiming = false, workingDirectory) {
+        const configuredWaitCap = Number(await configManager.getValue('maxProcessWaitMs'));
+        const waitCapMs = Number.isFinite(configuredWaitCap) && configuredWaitCap > 0 ? configuredWaitCap : 180000;
+        const effectiveWaitMs = Math.min(Math.max(0, timeoutMs), waitCapMs);
         // Get the shell from config if not specified
         let shellToUse = shell;
         if (!shellToUse) {
@@ -185,6 +194,8 @@ export class TerminalManager {
                 ...(workingDirectory ? { cwd: workingDirectory } : {})
             };
         }
+        // Inherited by nested shells/PTYs: a process-tool terminal is not owner-admin consent.
+        spawnOptions.env.MCP_DEVICE_SESSION = 'process-tool';
         // Repair PATHEXT on Windows before spawning. On some Windows DXT launches
         // the server process inherits a corrupted PATHEXT (e.g. ".CPL"), which we
         // would otherwise propagate via { ...process.env } and break command
@@ -229,11 +240,32 @@ export class TerminalManager {
                 isBlocked: false
             };
         }
+        // PID collision / reuse stopgap (1.0.10 P2.1):
+        // If a session with this PID already exists:
+        // - Check active sessions: if still live, reject with an explicit error to prevent aliasing.
+        // - Check completed sessions: if stale completed session exists, evict it cleanly.
+        if (this.sessions.has(childProcess.pid)) {
+            try {
+                childProcess.kill();
+            }
+            catch (killErr) {
+                console.error(`Failed to kill conflicting child process ${childProcess.pid}:`, killErr);
+            }
+            throw new Error(`PID collision detected: process ${childProcess.pid} is already running under an active session.`);
+        }
+        if (this.completedSessions.has(childProcess.pid)) {
+            console.warn(`[PID Collision] Evicting stale completed session for PID ${childProcess.pid}`);
+            this.completedSessions.delete(childProcess.pid);
+        }
         const session = {
+            executionId: randomUUID(),
             pid: childProcess.pid,
             process: childProcess,
             outputLines: [], // Line-based buffer
             lastReadIndex: 0, // Track where "new" output starts
+            lastReadOffset: 0, // Character offset inside a partially consumed line
+            outputVersion: 0,
+            outputWaiters: new Set(),
             isBlocked: false,
             startTime: new Date(),
             bufferedChars: 0,
@@ -256,6 +288,10 @@ export class TerminalManager {
                 if (resolved)
                     return;
                 resolved = true;
+                if (session.outputLines.length > 0) {
+                    const lineIndex = session.outputLines.length - 1;
+                    result.deliveredCursor = { lineIndex, lineOffset: session.outputLines[lineIndex].length };
+                }
                 if (periodicCheck)
                     clearInterval(periodicCheck);
                 // Add timing info if requested
@@ -388,32 +424,36 @@ export class TerminalManager {
                     output,
                     isBlocked: true
                 });
-            }, timeoutMs);
+            }, effectiveWaitMs);
+            let processExitCode = null;
             childProcess.on('exit', (code) => {
-                if (childProcess.pid) {
-                    // Store completed session before removing active session
-                    this.completedSessions.set(childProcess.pid, {
-                        pid: childProcess.pid,
-                        outputLines: [...session.outputLines], // Copy line buffer
-                        exitCode: code,
-                        startTime: session.startTime,
-                        endTime: new Date(),
-                        evictedLines: session.evictedLines,
-                        evictedChars: session.evictedChars
-                    });
-                    // Keep only last 100 completed sessions
-                    if (this.completedSessions.size > 100) {
-                        const oldestKey = Array.from(this.completedSessions.keys())[0];
-                        this.completedSessions.delete(oldestKey);
-                    }
-                    this.sessions.delete(childProcess.pid);
-                }
+                processExitCode = code;
                 exitReason = 'process_exit';
-                resolveOnce({
+                resolveOnce({ pid: childProcess.pid, output, isBlocked: false });
+            });
+            // Finalize only after stdio has closed so fast-exit stdout/stderr cannot be lost.
+            childProcess.on('close', (code) => {
+                if (!childProcess.pid)
+                    return;
+                this.completedSessions.set(childProcess.pid, {
+                    executionId: session.executionId,
                     pid: childProcess.pid,
-                    output,
-                    isBlocked: false
+                    outputLines: [...session.outputLines],
+                    exitCode: processExitCode ?? code,
+                    startTime: session.startTime,
+                    endTime: new Date(),
+                    evictedLines: session.evictedLines,
+                    evictedChars: session.evictedChars,
+                    lastReadIndex: session.lastReadIndex,
+                    lastReadOffset: session.lastReadOffset,
+                    bufferedChars: session.bufferedChars
                 });
+                if (this.completedSessions.size > 100) {
+                    const oldestKey = Array.from(this.completedSessions.keys())[0];
+                    this.completedSessions.delete(oldestKey);
+                }
+                this.notifyOutputProgress(session);
+                this.sessions.delete(childProcess.pid);
             });
         });
     }
@@ -421,6 +461,27 @@ export class TerminalManager {
      * Append text to a session's line buffer
      * Handles partial lines and newline splitting
      */
+    notifyOutputProgress(session) {
+        session.outputVersion++;
+        for (const waiter of session.outputWaiters)
+            waiter();
+        session.outputWaiters.clear();
+    }
+    async waitForOutputProgress(pid, sinceVersion, timeoutMs) {
+        const session = this.sessions.get(pid);
+        if (!session || session.outputVersion !== sinceVersion)
+            return;
+        await new Promise((resolve) => {
+            let timer;
+            const done = () => {
+                session.outputWaiters.delete(done);
+                clearTimeout(timer);
+                resolve();
+            };
+            session.outputWaiters.add(done);
+            timer = setTimeout(done, timeoutMs);
+        });
+    }
     appendToLineBuffer(session, text) {
         if (!text)
             return;
@@ -469,6 +530,7 @@ export class TerminalManager {
             if (session.lastReadIndex > 0)
                 session.lastReadIndex--;
         }
+        this.notifyOutputProgress(session);
     }
     /**
      * Read process output with pagination (like file reading)
@@ -477,9 +539,33 @@ export class TerminalManager {
      * @param length Max lines to return
      * @param updateReadIndex Whether to update lastReadIndex (default: true for offset=0)
      */
+    markOutputConsumed(pid, cursor) {
+        if (!cursor)
+            return;
+        const session = this.sessions.get(pid);
+        if (session) {
+            session.lastReadIndex = Math.min(cursor.lineIndex, Math.max(0, session.outputLines.length - 1));
+            session.lastReadOffset = cursor.lineOffset;
+            return;
+        }
+        const completed = this.completedSessions.get(pid);
+        if (completed) {
+            completed.lastReadIndex = Math.min(cursor.lineIndex, Math.max(0, completed.outputLines.length - 1));
+            completed.lastReadOffset = cursor.lineOffset;
+        }
+    }
     readOutputPaginated(pid, offset = 0, length = 1000) {
         // First check active sessions
         const session = this.sessions.get(pid);
+        if (session && offset === 0 && session.outputLines.length > 0) {
+            const start = Math.min(session.lastReadIndex, session.outputLines.length - 1);
+            const first = session.outputLines[start].slice(session.lastReadOffset);
+            const tail = session.outputLines.slice(start + 1, start + length);
+            const lines = first || tail.length === 0 ? [first, ...tail] : tail;
+            session.lastReadIndex = Math.min(start + lines.length - 1, session.outputLines.length - 1);
+            session.lastReadOffset = session.outputLines[session.lastReadIndex].length;
+            return { lines, totalLines: session.outputLines.length, readFrom: start, readCount: lines.length, remaining: Math.max(0, session.outputLines.length - start - lines.length), isComplete: false, evictedLines: session.evictedLines };
+        }
         if (session) {
             const result = this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
             result.evictedLines = session.evictedLines;
@@ -489,7 +575,7 @@ export class TerminalManager {
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
             const runtimeMs = completedSession.endTime.getTime() - completedSession.startTime.getTime();
-            const result = this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
+            const result = this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Protected baseline: completed sessions read from beginning and remain replayable
             () => { }, // No-op for completed sessions
             true, completedSession.exitCode, runtimeMs);
             result.evictedLines = completedSession.evictedLines;
@@ -588,17 +674,12 @@ export class TerminalManager {
      */
     captureOutputSnapshot(pid) {
         const session = this.sessions.get(pid);
-        if (session) {
-            const fullOutput = session.outputLines.join('\n');
-            return {
-                // Absolute since process start (includes evicted output), so the
-                // offset stays valid even if the cap evicts lines between
-                // snapshot and read.
-                totalChars: session.evictedChars + fullOutput.length,
-                lineCount: session.evictedLines + session.outputLines.length
-            };
-        }
-        return null;
+        if (!session)
+            return null;
+        return {
+            totalChars: session.evictedChars + session.bufferedChars,
+            lineCount: session.evictedLines + session.outputLines.length
+        };
     }
     /**
      * Get output that appeared since a snapshot was taken.
@@ -609,12 +690,12 @@ export class TerminalManager {
         // Check active session first
         const session = this.sessions.get(pid);
         if (session) {
-            return TerminalManager.outputSinceSnapshot(session.outputLines, session.evictedChars, snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(session.outputLines, session.bufferedChars, session.evictedChars, snapshot.totalChars);
         }
         // Fallback to completed sessions - process may have finished between snapshot and poll
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
-            return TerminalManager.outputSinceSnapshot(completedSession.outputLines, completedSession.evictedChars, snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(completedSession.outputLines, completedSession.bufferedChars, completedSession.evictedChars, snapshot.totalChars);
         }
         return null;
     }
@@ -623,13 +704,27 @@ export class TerminalManager {
      * If eviction dropped part of the unseen output, returns what the buffer
      * still holds — the oldest unseen chars are lost to the cap.
      */
-    static outputSinceSnapshot(outputLines, evictedChars, snapshotTotalChars) {
-        const fullOutput = outputLines.join('\n');
-        const newChars = evictedChars + fullOutput.length - snapshotTotalChars;
-        if (newChars <= 0) {
-            return ''; // No new output
+    static outputSinceSnapshot(outputLines, bufferedChars, evictedChars, snapshotTotalChars) {
+        const newChars = evictedChars + bufferedChars - snapshotTotalChars;
+        if (newChars <= 0)
+            return '';
+        let remaining = newChars;
+        const parts = [];
+        for (let i = outputLines.length - 1; i >= 0 && remaining > 0; i--) {
+            const line = outputLines[i];
+            const separator = i < outputLines.length - 1 ? 1 : 0;
+            const available = line.length + separator;
+            if (remaining >= available) {
+                parts.push((separator ? '\n' : '') + line);
+                remaining -= available;
+            }
+            else {
+                const suffixLength = Math.max(0, remaining - separator);
+                parts.push((separator ? '\n' : '') + line.slice(Math.max(0, line.length - suffixLength)));
+                remaining = 0;
+            }
         }
-        return fullOutput.substring(Math.max(0, fullOutput.length - newChars));
+        return parts.reverse().join('');
     }
     /**
    * Get a session by PID

package/dist/tool-dispatcher.d.ts

@@ -0,0 +1,11 @@
+import { ServerResult } from './types.js';
+export interface DispatchToolOptions {
+    isRemote?: boolean;
+    clientInfo?: {
+        name?: string;
+        version?: string;
+    };
+    origin?: string;
+    metadata?: any;
+}
+export declare function dispatchToolCall(name: string, args: any, options?: DispatchToolOptions): Promise<ServerResult>;

package/dist/tool-dispatcher.js

@@ -0,0 +1,228 @@
+import * as handlers from './handlers/index.js';
+import { getConfig, setConfigValue } from './tools/config.js';
+import { getUsageStats } from './tools/usage.js';
+import { getPrompts } from './tools/prompts.js';
+import { trackToolCall } from './utils/trackTools.js';
+import { usageTracker } from './utils/usageTracker.js';
+import { toolHistory } from './utils/toolHistory.js';
+import { observePublicInvocation, isCapturingInvocation } from './context/capture.js';
+import { capture } from './utils/capture.js';
+import { currentCallIsRemote, setCurrentCallIsRemote, setCurrentRemoteClient, } from './server.js';
+export async function dispatchToolCall(name, args, options = {}) {
+    return observePublicInvocation({ tool: name, args }, () => executeToolCall(name, args, options));
+}
+async function executeToolCall(name, args, options) {
+    const startTime = Date.now();
+    let telemetryData = { tool_name: name };
+    let result;
+    let isError = false;
+    try {
+        const isRemoteCall = Boolean(options.isRemote);
+        setCurrentCallIsRemote(isRemoteCall);
+        if (isRemoteCall) {
+            telemetryData.remote = String(options.isRemote);
+            const remoteClient = options.clientInfo && (options.clientInfo.name || options.clientInfo.version)
+                ? options.clientInfo
+                : { name: 'remote-unknown', version: 'unknown' };
+            setCurrentRemoteClient(remoteClient);
+            telemetryData.client_name = remoteClient.name;
+            telemetryData.client_version = remoteClient.version;
+        }
+        else {
+            setCurrentRemoteClient(null);
+        }
+        if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
+            telemetryData.set_config_value_key_name = args.key;
+        }
+        if (name === 'get_prompts' && args && typeof args === 'object') {
+            const promptArgs = args;
+            telemetryData.action = promptArgs.action;
+            if (promptArgs.category) {
+                telemetryData.category = promptArgs.category;
+                telemetryData.has_category_filter = true;
+            }
+            if (promptArgs.promptId) {
+                telemetryData.prompt_id = promptArgs.promptId;
+            }
+        }
+        trackToolCall(name, args);
+        switch (name) {
+            case 'get_config':
+                try {
+                    result = await getConfig();
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_config handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to get configuration' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'set_config_value':
+                try {
+                    result = await setConfigValue(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in set_config_value handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to set configuration value' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'get_usage_stats':
+                try {
+                    result = await getUsageStats();
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_usage_stats handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to get usage statistics' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'get_prompts':
+                try {
+                    result = await getPrompts(args || {});
+                    if (args && typeof args === 'object' && !result.isError) {
+                        const action = args.action;
+                        try {
+                            if (action === 'get_prompt' && args.promptId) {
+                                const { loadPromptsData } = await import('./tools/prompts.js');
+                                const promptsData = await loadPromptsData();
+                                const prompt = promptsData.prompts.find(p => p.id === args.promptId);
+                                if (prompt) {
+                                    await capture('server_get_prompt', {
+                                        prompt_id: prompt.id,
+                                        prompt_title: prompt.title,
+                                        category: prompt.categories[0] || 'uncategorized',
+                                        author: prompt.author,
+                                        verified: prompt.verified,
+                                    });
+                                }
+                            }
+                        }
+                        catch (error) { }
+                    }
+                    const onboardingState = await usageTracker.getOnboardingState();
+                    if (onboardingState.attemptsShown > 0 && !onboardingState.promptsUsed) {
+                        await usageTracker.markOnboardingPromptsUsed();
+                    }
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_prompts handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to retrieve prompts' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'get_recent_tool_calls':
+                try {
+                    result = await handlers.handleGetRecentToolCalls(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_recent_tool_calls handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to get tool call history' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'track_ui_event':
+                try {
+                    result = await handlers.handleTrackUiEvent(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in track_ui_event handler: ${error}` });
+                    result = {
+                        content: [{ type: 'text', text: 'Error: Failed to track UI event' }],
+                        isError: true,
+                    };
+                }
+                break;
+            case 'start_process':
+                result = await handlers.handleStartProcess(args);
+                break;
+            case 'read_process_output':
+                result = await handlers.handleReadProcessOutput(args);
+                break;
+            case 'interact_with_process':
+                result = await handlers.handleInteractWithProcess(args);
+                break;
+            case 'force_terminate':
+                result = await handlers.handleForceTerminate(args);
+                break;
+            case 'list_sessions':
+                result = await handlers.handleListSessions();
+                break;
+            case 'list_processes':
+                result = await handlers.handleListProcesses();
+                break;
+            case 'kill_process':
+                result = await handlers.handleKillProcess(args);
+                break;
+            case 'read_file':
+                result = await handlers.handleReadFile(args);
+                break;
+            case 'read_multiple_files':
+                result = await handlers.handleReadMultipleFiles(args);
+                break;
+            case 'write_file':
+                result = await handlers.handleWriteFile(args);
+                break;
+            case 'write_pdf':
+                result = await handlers.handleWritePdf(args);
+                break;
+            case 'create_directory':
+                result = await handlers.handleCreateDirectory(args);
+                break;
+            case 'list_directory':
+                result = await handlers.handleListDirectory(args);
+                break;
+            case 'move_file':
+                result = await handlers.handleMoveFile(args);
+                break;
+            case 'start_search':
+                result = await handlers.handleStartSearch(args);
+                break;
+            case 'get_more_search_results':
+                result = await handlers.handleGetMoreSearchResults(args);
+                break;
+            case 'stop_search':
+                result = await handlers.handleStopSearch(args);
+                break;
+            case 'list_searches':
+                result = await handlers.handleListSearches();
+                break;
+            case 'get_file_info':
+                result = await handlers.handleGetFileInfo(args);
+                break;
+            case 'edit_block':
+                result = await handlers.handleEditBlock(args);
+                break;
+            default:
+                capture('server_unknown_tool', { name });
+                result = {
+                    content: [{ type: 'text', text: `Error: Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+        const duration = Date.now() - startTime;
+        isError = !!result.isError;
+        const EXCLUDED_TOOLS = ['get_recent_tool_calls', 'track_ui_event'];
+        if (!isCapturingInvocation() && !currentCallIsRemote && process.env.MCP_DEVICE_REMOTE !== 'true' && !EXCLUDED_TOOLS.includes(name)) {
+            toolHistory.addCall(name, args, result, duration);
+        }
+        return result;
+    }
+    catch (error) {
+        capture('server_unhandled_tool_error', { name, error: error?.message || String(error) });
+        return {
+            content: [{ type: 'text', text: `Error executing ${name}: ${error?.message || String(error)}` }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/edit.js

@@ -82,7 +82,26 @@ function getCharacterCodeData(expected, actual) {
         diffLength: fullDiff.length
     };
 }
-export async function performSearchReplace(filePath, block, expectedReplacements = 1, origin) {
+const editChains = new Map();
+async function withFileEditLock(filePath, operation) {
+    const resolved = path.resolve(filePath);
+    const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    const previous = editChains.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    const tail = previous.then(() => current);
+    editChains.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (editChains.get(key) === tail)
+            editChains.delete(key);
+    }
+}
+async function performSearchReplaceUnlocked(filePath, block, expectedReplacements = 1, origin) {
     // Get file extension for telemetry using path module
     const fileExtension = path.extname(filePath).toLowerCase();
     // Capture file extension and string sizes in telemetry without capturing the file path
@@ -288,6 +307,49 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
     }
     throw new Error("Unexpected error during search and replace operation.");
 }
+export async function performSearchReplace(filePath, block, expectedReplacements = 1, origin) {
+    return withFileEditLock(filePath, () => performSearchReplaceUnlocked(filePath, block, expectedReplacements, origin));
+}
+async function performExactBatch(filePath, edits, origin) {
+    return withFileEditLock(filePath, async () => {
+        const validPath = await validatePath(filePath);
+        const original = await readFileInternal(validPath, 0, Number.MAX_SAFE_INTEGER);
+        const fileLineEnding = detectLineEnding(original);
+        let next = original;
+        for (const edit of edits) {
+            const search = normalizeLineEndings(edit.old_string, fileLineEnding);
+            const replacement = normalizeLineEndings(edit.new_string, fileLineEnding);
+            let count = 0;
+            let pos = next.indexOf(search);
+            while (pos !== -1) {
+                count++;
+                pos = next.indexOf(search, pos + Math.max(1, search.length));
+            }
+            if (count !== edit.expected_replacements) {
+                return createErrorResponse(`Expected ${edit.expected_replacements} occurrences but found ${count} for batched edit in ${filePath}. No changes were written.`);
+            }
+            next = count === 1
+                ? next.replace(search, replacement)
+                : next.split(search).join(replacement);
+        }
+        await writeFile(filePath, next);
+        const resolvedEditPath = resolveAbsolutePath(filePath);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully applied ${edits.length} exact edit(s) to ${filePath}`
+                }],
+            ...(origin === 'ui' ? {
+                structuredContent: {
+                    fileName: path.basename(resolvedEditPath),
+                    filePath: resolvedEditPath,
+                    fileType: resolvePreviewFileType(resolvedEditPath),
+                    ...await getDefaultEditorMetadata(resolvedEditPath),
+                },
+            } : {}),
+        };
+    });
+}
 /**
  * Generates a character-level diff using standard {-removed-}{+added+} format
  * @param expected The string that was searched for
@@ -350,6 +412,15 @@ export async function handleEditBlock(args) {
         return createErrorResponse(errorMessage);
     }
     const hasEditRange = 'editRange' in handler && typeof handler.editRange === 'function';
+    // Compact hot path: multiple exact text replacements share one read/write.
+    // Structured handlers keep their existing editRange behavior and do not
+    // opt into this text-only batch contract.
+    if (parsed.edits) {
+        if (hasEditRange) {
+            return createErrorResponse(`Batched exact text edits are not supported for structured file ${parsed.file_path}; use the existing range/text edit contract for that file type.`);
+        }
+        return performExactBatch(parsed.file_path, parsed.edits, parsed.origin);
+    }
     // Path 1: Range rewrite (Excel, etc.) — range + content
     if (hasRange && hasContent) {
         // Parse content if it's a JSON string (AI often sends arrays as JSON strings)

package/dist/tools/filesystem.d.ts

@@ -57,7 +57,7 @@ export interface MultiFileResult {
     isPdf?: boolean;
     payload?: FileResultPayloads;
 }
-export declare function readMultipleFiles(paths: string[]): Promise<MultiFileResult[]>;
+export declare function readMultipleFiles(paths: string[], options?: ReadOptions): Promise<MultiFileResult[]>;
 export declare function createDirectory(dirPath: string): Promise<void>;
 export declare function listDirectory(dirPath: string, depth?: number): Promise<string[]>;
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;

package/dist/tools/filesystem.js

@@ -563,11 +563,11 @@ export async function writeFile(filePath, content, mode = 'rewrite') {
     // Use handler to write the file
     await handler.write(validPath, content, mode);
 }
-export async function readMultipleFiles(paths) {
+export async function readMultipleFiles(paths, options) {
     return Promise.all(paths.map(async (filePath) => {
         try {
             const validPath = await validatePath(filePath);
-            const fileResult = await readFile(validPath);
+            const fileResult = await readFile(validPath, options);
             // Handle content conversion properly for images vs text
             let content;
             if (typeof fileResult.content === 'string') {