@hcu-lab.me/mcp-device 1.0.8 → 1.0.10

package/dist/tool-dispatcher.js

@@ -0,0 +1,224 @@
+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 { capture } from './utils/capture.js';
+import { currentCallIsRemote, setCurrentCallIsRemote, setCurrentRemoteClient, } from './server.js';
+export async function dispatchToolCall(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 (!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') {

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

@@ -17,6 +17,24 @@ 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
+const processOperationTails = new Map();
+async function acquireProcessOperation(pid) {
+    const previous = processOperationTails.get(pid) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => { release = resolve; });
+    const tail = previous.catch(() => { }).then(() => current);
+    processOperationTails.set(pid, tail);
+    await previous.catch(() => { });
+    return () => {
+        release();
+        if (processOperationTails.get(pid) === tail) {
+            tail.finally(() => {
+                if (processOperationTails.get(pid) === tail)
+                    processOperationTails.delete(pid);
+            });
+        }
+    };
+}
 /**
  * Execute Node.js code via temp file (fallback when Python unavailable)
  * Creates temp .mjs file in MCP directory for ES module import access
@@ -152,13 +170,18 @@ export async function startProcess(args) {
             }
         }
     }
-    const result = await terminalManager.executeCommand(commandToRun, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false, workingDirectory);
+    const result = await terminalManager.executeCommand(commandToRun, parsed.data.background ? 0 : (parsed.data.yield_ms ?? parsed.data.timeout_ms), shellUsed, parsed.data.verbose_timing || false, workingDirectory);
     if (result.pid === -1) {
         return {
             content: [{ type: "text", text: result.output }],
             isError: true,
         };
     }
+    // Initial output returned here is already delivered to the consuming caller.
+    // Note: Only mark consumed for active running processes; completed processes retain baseline replayability.
+    if (terminalManager.getSession(result.pid)) {
+        terminalManager.markOutputConsumed(result.pid, result.deliveredCursor);
+    }
     // Analyze the process state to detect if it's waiting for input
     const processState = analyzeProcessState(result.output, result.pid);
     let statusMessage = '';
@@ -225,48 +248,15 @@ export async function readProcessOutput(args) {
     verbose_timing = false } = parsed.data;
     // Timing telemetry
     const startTime = Date.now();
-    // For active sessions with no new output yet, optionally wait for output
+    // For active sessions with no unread bytes yet, wait on output/completion progress.
     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;
-                }
-                let resolved = false;
-                let interval = null;
-                let timeout = null;
-                const cleanup = () => {
-                    if (interval)
-                        clearInterval(interval);
-                    if (timeout)
-                        clearTimeout(timeout);
-                };
-                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();
-                    }
-                }, 50);
-                // Timeout
-                timeout = setTimeout(() => {
-                    resolveOnce();
-                }, timeout_ms);
-            });
-        };
-        await waitForOutput();
+        const currentLine = session.outputLines[session.lastReadIndex];
+        const hasUnread = currentLine !== undefined && session.lastReadOffset < currentLine.length
+            || session.outputLines.length - 1 > session.lastReadIndex;
+        if (!hasUnread) {
+            await terminalManager.waitForOutputProgress(pid, session.outputVersion, timeout_ms);
+        }
     }
     // Read output with pagination
     const result = terminalManager.readOutputPaginated(pid, offset, length);
@@ -313,9 +303,8 @@ export async function readProcessOutput(args) {
         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);
+        // Analyze only the newly returned/bounded output; never rescan retained history here.
+        const processState = analyzeProcessState(output, pid);
         if (processState.isWaitingForInput) {
             processStateMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
         }
@@ -350,9 +339,12 @@ 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
+    // Get config for output line limit and cap a single blocking interaction below client ceilings.
     const config = await configManager.getConfig();
     const maxOutputLines = config.fileReadLineLimit ?? 1000;
+    const configuredWaitCap = Number(await configManager.getValue('maxProcessWaitMs'));
+    const waitCapMs = Number.isFinite(configuredWaitCap) && configuredWaitCap > 0 ? configuredWaitCap : 180000;
+    const effectiveTimeoutMs = Math.min(Math.max(0, timeout_ms), waitCapMs);
     // Check if this is a virtual Node session (node:local)
     if (virtualNodeSessions.has(pid)) {
         const session = virtualNodeSessions.get(pid);
@@ -371,6 +363,7 @@ export async function interactWithProcess(args) {
     let lastOutputTime;
     const outputEvents = [];
     let exitReason = 'timeout';
+    const releaseOperation = await acquireProcessOperation(pid);
     try {
         capture('server_interact_with_process', {
             pid: pid,
@@ -417,72 +410,55 @@ export async function interactWithProcess(args) {
         let earlyExit = false;
         // Quick prompt patterns for immediate detection
         const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
-        const waitForResponse = () => {
-            return new Promise((resolve) => {
-                let resolved = false;
-                let attempts = 0;
-                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;
-                    resolved = true;
-                    if (interval)
-                        clearInterval(interval);
-                    resolve();
-                };
-                // Fast-polling check - check every 50ms for quick responses
-                interval = setInterval(() => {
-                    if (resolved)
-                        return;
-                    // 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;
-                        lastOutputTime = now;
-                        if (verbose_timing) {
-                            outputEvents.push({
-                                timestamp: now,
-                                deltaMs: now - startTime,
-                                source: 'periodic_poll',
-                                length: newOutput.length - lastOutputLength,
-                                snippet: newOutput.slice(lastOutputLength, lastOutputLength + 50).replace(/\n/g, '\\n')
-                            });
-                        }
-                        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
-                        if (processState.isWaitingForInput) {
-                            earlyExit = true;
-                            exitReason = 'early_exit_periodic_check';
-                            if (verbose_timing && outputEvents.length > 0) {
-                                outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
-                            }
-                            resolveOnce();
-                            return;
-                        }
-                        // Also exit if process finished
-                        if (processState.isFinished) {
-                            exitReason = 'process_finished';
-                            resolveOnce();
-                            return;
+        const waitForResponse = async () => {
+            const deadline = Date.now() + effectiveTimeoutMs;
+            let lastOutputLength = 0;
+            while (Date.now() < deadline) {
+                const active = terminalManager.getSession(pid);
+                const version = active?.outputVersion ?? -1;
+                const newOutput = outputSnapshot
+                    ? terminalManager.getOutputSinceSnapshot(pid, outputSnapshot)
+                    : terminalManager.getNewOutput(pid);
+                if (newOutput && newOutput.length > lastOutputLength) {
+                    const now = Date.now();
+                    if (!firstOutputTime)
+                        firstOutputTime = now;
+                    lastOutputTime = now;
+                    if (verbose_timing) {
+                        outputEvents.push({
+                            timestamp: now,
+                            deltaMs: now - startTime,
+                            source: 'output_event',
+                            length: newOutput.length - lastOutputLength,
+                            snippet: newOutput.slice(lastOutputLength, lastOutputLength + 50).replace(/\n/g, '\\n')
+                        });
+                    }
+                    output = newOutput;
+                    lastOutputLength = newOutput.length;
+                    processState = analyzeProcessState(output, pid);
+                    if (processState.isWaitingForInput) {
+                        earlyExit = true;
+                        exitReason = 'early_exit_periodic_check';
+                        if (verbose_timing && outputEvents.length > 0) {
+                            outputEvents[outputEvents.length - 1].matchedPattern = 'output_event';
                         }
+                        return;
                     }
-                    attempts++;
-                    if (attempts >= maxAttempts) {
-                        exitReason = 'timeout';
-                        resolveOnce();
+                    if (processState.isFinished) {
+                        exitReason = 'process_finished';
+                        return;
                     }
-                }, pollIntervalMs);
-            });
+                }
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                if (!active) {
+                    exitReason = 'process_finished';
+                    return;
+                }
+                await terminalManager.waitForOutputProgress(pid, version, remaining);
+            }
+            exitReason = 'timeout';
         };
         await waitForResponse();
         // Clean and format output
@@ -569,6 +545,9 @@ export async function interactWithProcess(args) {
             isError: true,
         };
     }
+    finally {
+        releaseOperation();
+    }
 }
 /**
  * Force terminate a process