@wonderwhy-er/desktop-commander 0.2.41 → 0.2.43

package/dist/tools/fuzzySearch.js

@@ -1,113 +1,74 @@
-import { distance } from 'fastest-levenshtein';
 import { capture } from '../utils/capture.js';
+import { Worker } from 'worker_threads';
+// Re-export so existing callers keep importing from this module.
+export { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearchCore.js';
+/** Abort fuzzy search in the worker after this many ms to avoid unbounded CPU burn. */
+export const FUZZY_SEARCH_TIMEOUT_MS = 30000;
 /**
- * Recursively finds the closest match to a query string within text using fuzzy matching
- * @param text The text to search within
- * @param query The query string to find
- * @param start Start index in the text (default: 0)
- * @param end End index in the text (default: text.length)
- * @param parentDistance Best distance found so far (default: Infinity)
- * @returns Object with start and end indices, matched value, and Levenshtein distance
+ * Inline worker entry: imports the dependency-free core module (passed as
+ * moduleUrl) and runs the search off the main thread. The core module is
+ * deliberately a leaf — importing this module (or anything app-level) from the
+ * worker would boot the whole server per search. Kept as an eval'd snippet so
+ * the worker needs no separate file to ship alongside the compiled output.
  */
-export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity, depth = 0) {
-    // For debugging and performance tracking purposes
-    if (depth === 0) {
-        const startTime = performance.now();
-        const result = recursiveFuzzyIndexOf(text, query, start, end, parentDistance, depth + 1);
-        const executionTime = performance.now() - startTime;
-        // Capture detailed metrics for the recursive search for in-depth analysis
-        capture('fuzzy_search_recursive_metrics', {
-            execution_time_ms: executionTime,
-            text_length: text.length,
-            query_length: query.length,
-            result_distance: result.distance
-        });
-        return result;
-    }
-    if (end === null)
-        end = text.length;
-    // For small text segments, use iterative approach
-    if (end - start <= 2 * query.length) {
-        return iterativeReduction(text, query, start, end, parentDistance);
-    }
-    let midPoint = start + Math.floor((end - start) / 2);
-    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
-    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
-    // Calculate distance for current segments
-    let leftDistance = distance(text.substring(start, leftEnd), query);
-    let rightDistance = distance(text.substring(rightStart, end), query);
-    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
-    // If parent distance is already the best, use iterative approach
-    if (parentDistance === bestDistance) {
-        return iterativeReduction(text, query, start, end, parentDistance);
-    }
-    // Recursively search the better half
-    if (leftDistance < rightDistance) {
-        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance, depth + 1);
-    }
-    else {
-        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance, depth + 1);
-    }
-}
+const WORKER_CODE = `
+const { workerData, parentPort } = require('worker_threads');
+import(workerData.moduleUrl)
+    .then((m) => {
+        parentPort.postMessage({ ok: true, ...m.runFuzzySearch(workerData.text, workerData.query) });
+    })
+    .catch((err) => {
+        parentPort.postMessage({ ok: false, error: String(err && err.stack || err) });
+    });
+`;
+const CORE_MODULE_URL = new URL('./fuzzySearchCore.js', import.meta.url).href;
 /**
- * Iteratively refines the best match by reducing the search area
- * @param text The text to search within
- * @param query The query string to find
- * @param start Start index in the text
- * @param end End index in the text
- * @param parentDistance Best distance found so far
- * @returns Object with start and end indices, matched value, and Levenshtein distance
+ * Runs the fuzzy search in a Worker thread so the main MCP event loop stays
+ * responsive to pings and other tool calls during heavy scans. Rejects if the
+ * scan exceeds timeoutMs, terminating the worker so it doesn't linger in the
+ * background. Search metrics come back with the result and are captured here,
+ * on the main thread, where the client identity is initialized.
  */
-function iterativeReduction(text, query, start, end, parentDistance) {
-    const startTime = performance.now();
-    let iterations = 0;
-    let bestDistance = parentDistance;
-    let bestStart = start;
-    let bestEnd = end;
-    // Improve start position
-    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
-    while (nextDistance < bestDistance) {
-        bestDistance = nextDistance;
-        bestStart++;
-        const smallerString = text.substring(bestStart + 1, bestEnd);
-        nextDistance = distance(smallerString, query);
-        iterations++;
-    }
-    // Improve end position
-    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
-    while (nextDistance < bestDistance) {
-        bestDistance = nextDistance;
-        bestEnd--;
-        const smallerString = text.substring(bestStart, bestEnd - 1);
-        nextDistance = distance(smallerString, query);
-        iterations++;
-    }
-    const executionTime = performance.now() - startTime;
-    // Capture metrics for the iterative refinement phase
-    capture('fuzzy_search_iterative_metrics', {
-        execution_time_ms: executionTime,
-        iterations: iterations,
-        segment_length: end - start,
-        query_length: query.length,
-        final_distance: bestDistance
+export function runFuzzySearchInWorker(text, query, timeoutMs = FUZZY_SEARCH_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(WORKER_CODE, { eval: true, workerData: { moduleUrl: CORE_MODULE_URL, text, query } });
+        // Never let a scan keep the server process alive during shutdown.
+        worker.unref();
+        const timer = setTimeout(() => {
+            worker.terminate();
+            reject(new Error(`Fuzzy search timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref();
+        worker.on('message', (msg) => {
+            clearTimeout(timer);
+            if (msg.ok) {
+                captureFuzzySearchMetrics(msg.metrics);
+                resolve(msg.result);
+            }
+            else {
+                reject(new Error(`Fuzzy search worker failed: ${msg.error}`));
+            }
+            // Don't let the worker wind down on its own; the answer is already
+            // here, and a lingering worker holds its copy of the file text.
+            // The promise is settled, so the exit-code rejection below is a no-op.
+            worker.terminate();
+        });
+        worker.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        worker.on('exit', (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`Fuzzy search worker exited with code ${code}`));
+            }
+        });
     });
-    return {
-        start: bestStart,
-        end: bestEnd,
-        value: text.substring(bestStart, bestEnd),
-        distance: bestDistance
-    };
 }
-/**
- * Calculates the similarity ratio between two strings
- * @param a First string
- * @param b Second string
- * @returns Similarity ratio (0-1)
- */
-export function getSimilarityRatio(a, b) {
-    const maxLength = Math.max(a.length, b.length);
-    if (maxLength === 0)
-        return 1; // Both strings are empty
-    const levenshteinDistance = distance(a, b);
-    return 1 - (levenshteinDistance / maxLength);
+/** Same telemetry events the search used to emit inline, now sent from the main thread. */
+function captureFuzzySearchMetrics(metrics) {
+    capture('fuzzy_search_recursive_metrics', metrics.recursive);
+    if (metrics.iterative) {
+        capture('fuzzy_search_iterative_metrics', metrics.iterative);
+    }
 }

package/dist/tools/fuzzySearchCore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure fuzzy-search core, kept free of app imports on purpose: it runs inside
+ * the worker thread spawned by runFuzzySearchInWorker (fuzzySearch.ts), and
+ * anything imported here is loaded per worker. Telemetry is returned as data
+ * and captured on the main thread, which has the real client identity.
+ */
+export interface FuzzyMatch {
+    start: number;
+    end: number;
+    value: string;
+    distance: number;
+}
+export interface FuzzySearchMetrics {
+    recursive: {
+        execution_time_ms: number;
+        text_length: number;
+        query_length: number;
+        result_distance: number;
+    };
+    iterative: {
+        execution_time_ms: number;
+        iterations: number;
+        segment_length: number;
+        query_length: number;
+        final_distance: number;
+    } | null;
+}
+/**
+ * Runs a full fuzzy search and returns the match together with the timing
+ * metrics that used to be captured inline.
+ */
+export declare function runFuzzySearch(text: string, query: string): {
+    result: FuzzyMatch;
+    metrics: FuzzySearchMetrics;
+};
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number): FuzzyMatch;
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export declare function getSimilarityRatio(a: string, b: string): number;

package/dist/tools/fuzzySearchCore.js

@@ -0,0 +1,125 @@
+import { distance } from 'fastest-levenshtein';
+// Set by iterativeReduction during a search (exactly one terminal call per
+// search) and collected by runFuzzySearch. Single-threaded per context, so a
+// module-level slot is safe.
+let lastIterativeMetrics = null;
+/**
+ * Runs a full fuzzy search and returns the match together with the timing
+ * metrics that used to be captured inline.
+ */
+export function runFuzzySearch(text, query) {
+    const startTime = performance.now();
+    lastIterativeMetrics = null;
+    const result = recursiveFuzzyIndexOf(text, query);
+    return {
+        result,
+        metrics: {
+            recursive: {
+                execution_time_ms: performance.now() - startTime,
+                text_length: text.length,
+                query_length: query.length,
+                result_distance: result.distance
+            },
+            iterative: lastIterativeMetrics
+        }
+    };
+}
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity) {
+    if (end === null)
+        end = text.length;
+    // For small text segments, use iterative approach
+    if (end - start <= 2 * query.length) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    let midPoint = start + Math.floor((end - start) / 2);
+    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
+    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
+    // Calculate distance for current segments
+    let leftDistance = distance(text.substring(start, leftEnd), query);
+    let rightDistance = distance(text.substring(rightStart, end), query);
+    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
+    // If parent distance is already the best, use iterative approach
+    if (parentDistance === bestDistance) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    // Recursively search the better half
+    if (leftDistance < rightDistance) {
+        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance);
+    }
+    else {
+        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance);
+    }
+}
+/**
+ * Iteratively refines the best match by reducing the search area
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text
+ * @param end End index in the text
+ * @param parentDistance Best distance found so far
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+function iterativeReduction(text, query, start, end, parentDistance) {
+    const startTime = performance.now();
+    let iterations = 0;
+    // Seed with the measured distance of this slice. For recursive callers
+    // this equals parentDistance (the parent measured exactly this slice), but
+    // a top-level call on text <= 2x query length arrives with Infinity, which
+    // made the first shrink unconditional and a position-0 match unreachable.
+    let bestDistance = distance(text.substring(start, end), query);
+    let bestStart = start;
+    let bestEnd = end;
+    // Improve start position
+    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestStart++;
+        const smallerString = text.substring(bestStart + 1, bestEnd);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    // Improve end position
+    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestEnd--;
+        const smallerString = text.substring(bestStart, bestEnd - 1);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    lastIterativeMetrics = {
+        execution_time_ms: performance.now() - startTime,
+        iterations: iterations,
+        segment_length: end - start,
+        query_length: query.length,
+        final_distance: bestDistance
+    };
+    return {
+        start: bestStart,
+        end: bestEnd,
+        value: text.substring(bestStart, bestEnd),
+        distance: bestDistance
+    };
+}
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export function getSimilarityRatio(a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    if (maxLength === 0)
+        return 1; // Both strings are empty
+    const levenshteinDistance = distance(a, b);
+    return 1 - (levenshteinDistance / maxLength);
+}

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

@@ -1,4 +1,4 @@
-import { terminalManager } from '../terminal-manager.js';
+import { terminalManager, MAX_BUFFERED_OUTPUT_CHARS } from '../terminal-manager.js';
 import { commandManager } from '../command-manager.js';
 import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
 import { capture } from "../utils/capture.js";
@@ -293,6 +293,13 @@ export async function readProcessOutput(args) {
         // Absolute position read
         statusMessage = `[Reading ${result.readCount} lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
     }
+    // Surface buffer-cap eviction so the model knows the retained output is not
+    // the full output and that line numbers shifted (matches the truncation
+    // markers used by other tools).
+    if (result.evictedLines && result.evictedLines > 0) {
+        const capMB = Math.round(MAX_BUFFERED_OUTPUT_CHARS / 1024 / 1024);
+        statusMessage += `\n[WARNING: output exceeded the ${capMB}MB buffer cap; the ${result.evictedLines} earliest lines were evicted and cannot be read. Line numbers and totals refer to the retained buffer only]`;
+    }
     // Add process state info
     let processStateMessage = '';
     if (result.isComplete) {

package/dist/tools/pdf/markdown.d.ts

@@ -1,5 +1,17 @@
 import type { PageRange } from './lib/pdf2md.js';
 import { PdfParseResult } from './lib/pdf2md.js';
+interface CachedPuppeteerChrome {
+    executablePath: string;
+}
+/**
+ * Find Chrome in puppeteer's cache directory
+ * Returns the executable path if found, undefined otherwise
+ */
+export declare function findPuppeteerChrome(cacheDir?: string): CachedPuppeteerChrome | undefined;
+/**
+ * Remove stale Puppeteer Chrome builds while preserving the active build.
+ */
+export declare function pruneOldPuppeteerChromeBuilds(activeExecutablePath: string, cacheDir?: string): Promise<void>;
 /**
  * Preemptively ensure Chrome is available for PDF generation.
  * Call this at server startup to trigger download in background if needed.
@@ -11,3 +23,4 @@ export declare function ensureChromeAvailable(): void;
  */
 export declare function parsePdfToMarkdown(source: string, pageNumbers?: number[] | PageRange): Promise<PdfParseResult>;
 export declare function parseMarkdownToPdf(markdown: string, options?: any): Promise<Buffer>;
+export {};

package/dist/tools/pdf/markdown.js

@@ -1,48 +1,76 @@
 import fs from 'fs/promises';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { mdToPdf } from 'md-to-pdf';
 import { pdf2md } from './lib/pdf2md.js';
+import { CONFIG_FILE } from '../../config.js';
 const isUrl = (source) => source.startsWith('http://') || source.startsWith('https://');
 // Cached Chrome path to avoid repeated lookups
 let cachedChromePath = null; // null = not checked yet
 let chromeCheckPromise = null;
 /**
- * Get the puppeteer cache directory
+ * Get Desktop Commander's private Puppeteer cache directory.
  */
 function getPuppeteerCacheDir() {
-    return join(homedir(), '.cache', 'puppeteer');
+    return join(dirname(CONFIG_FILE), 'puppeteer-cache');
+}
+/**
+ * Get the cache path where Puppeteer stores Chrome for Testing builds.
+ */
+function getPuppeteerChromeDir(cacheDir = getPuppeteerCacheDir()) {
+    return join(cacheDir, 'chrome');
+}
+/**
+ * Find the platform-specific executable within a cached Chrome build directory.
+ */
+function getChromeExecutablePath(chromeDir, version) {
+    const chromePath = process.platform === 'win32'
+        ? join(chromeDir, version, 'chrome-win64', 'chrome.exe')
+        : process.platform === 'darwin'
+            ? join(chromeDir, version, 'chrome-mac-x64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing')
+            : join(chromeDir, version, 'chrome-linux64', 'chrome');
+    if (existsSync(chromePath)) {
+        return chromePath;
+    }
+    // Also check for arm64 mac
+    if (process.platform === 'darwin') {
+        const armPath = join(chromeDir, version, 'chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+        if (existsSync(armPath)) {
+            return armPath;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the cached Chrome build directory that owns an executable path.
+ */
+function getCachedChromeBuildDir(chromeDir, executablePath) {
+    const relativePath = relative(chromeDir, executablePath);
+    if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        return undefined;
+    }
+    const [buildDir] = relativePath.split(sep);
+    return buildDir ? join(chromeDir, buildDir) : undefined;
 }
 /**
  * Find Chrome in puppeteer's cache directory
  * Returns the executable path if found, undefined otherwise
  */
-function findPuppeteerChrome() {
-    const cacheDir = getPuppeteerCacheDir();
-    const chromeDir = join(cacheDir, 'chrome');
+export function findPuppeteerChrome(cacheDir = getPuppeteerCacheDir()) {
+    const chromeDir = getPuppeteerChromeDir(cacheDir);
     if (!existsSync(chromeDir)) {
         return undefined;
     }
     try {
         // Look for chrome directories (e.g., win64-143.0.7499.169)
-        const { readdirSync } = require('fs');
-        const versions = readdirSync(chromeDir);
+        const versions = readdirSync(chromeDir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name)
+            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
         for (const version of versions) {
-            const chromePath = process.platform === 'win32'
-                ? join(chromeDir, version, 'chrome-win64', 'chrome.exe')
-                : process.platform === 'darwin'
-                    ? join(chromeDir, version, 'chrome-mac-x64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing')
-                    : join(chromeDir, version, 'chrome-linux64', 'chrome');
-            if (existsSync(chromePath)) {
-                return chromePath;
-            }
-            // Also check for arm64 mac
-            if (process.platform === 'darwin') {
-                const armPath = join(chromeDir, version, 'chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
-                if (existsSync(armPath)) {
-                    return armPath;
-                }
+            const executablePath = getChromeExecutablePath(chromeDir, version);
+            if (executablePath) {
+                return { executablePath };
             }
         }
     }
@@ -51,6 +79,37 @@ function findPuppeteerChrome() {
     }
     return undefined;
 }
+/**
+ * Remove stale Puppeteer Chrome builds while preserving the active build.
+ */
+export async function pruneOldPuppeteerChromeBuilds(activeExecutablePath, cacheDir = getPuppeteerCacheDir()) {
+    const chromeDir = getPuppeteerChromeDir(cacheDir);
+    const activeBuildDir = getCachedChromeBuildDir(chromeDir, activeExecutablePath);
+    if (!activeBuildDir) {
+        return;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(chromeDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    await Promise.all(entries
+        .filter(entry => entry.isDirectory())
+        .map(async (entry) => {
+        const buildDir = join(chromeDir, entry.name);
+        if (resolve(buildDir) === resolve(activeBuildDir)) {
+            return;
+        }
+        try {
+            await fs.rm(buildDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.error(`Failed to remove old Chrome cache build at ${buildDir}:`, error);
+        }
+    }));
+}
 /**
  * Find system-installed Chrome/Chromium browser
  * Returns the executable path if found, undefined otherwise
@@ -91,6 +150,7 @@ async function installChrome() {
     const platform = detectBrowserPlatform();
     const buildId = await resolveBuildId(Browser.CHROME, platform, 'stable');
     console.error('Downloading Chrome for PDF generation (this may take a few minutes)...');
+    await fs.mkdir(cacheDir, { recursive: true });
     const installedBrowser = await install({
         browser: Browser.CHROME,
         buildId,
@@ -101,7 +161,9 @@ async function installChrome() {
         },
     });
     console.error('\nChrome download complete.');
-    return installedBrowser.executablePath;
+    return {
+        executablePath: installedBrowser.executablePath,
+    };
 }
 /**
  * Find or install Chrome for PDF generation
@@ -122,8 +184,9 @@ async function getChromePath() {
         // 1. Check puppeteer cache first (exact compatible version)
         const cachedChrome = findPuppeteerChrome();
         if (cachedChrome) {
-            cachedChromePath = cachedChrome;
-            return cachedChrome;
+            await pruneOldPuppeteerChromeBuilds(cachedChrome.executablePath);
+            cachedChromePath = cachedChrome.executablePath;
+            return cachedChrome.executablePath;
         }
         // 2. Check system Chrome
         const systemChrome = findSystemChrome();
@@ -134,8 +197,9 @@ async function getChromePath() {
         // 3. Install Chrome as last resort
         try {
             const installedChrome = await installChrome();
-            cachedChromePath = installedChrome;
-            return installedChrome;
+            await pruneOldPuppeteerChromeBuilds(installedChrome.executablePath);
+            cachedChromePath = installedChrome.executablePath;
+            return installedChrome.executablePath;
         }
         catch (error) {
             console.error('Failed to install Chrome:', error);