@wonderwhy-er/desktop-commander 0.2.41 → 0.2.43

package/dist/setup-claude-server.js

@@ -10,10 +10,9 @@ import { version as nodeVersion } from 'process';
 import * as https from 'https';
 import { randomUUID } from 'crypto';
 
-// Google Analytics configuration
-const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
-const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';   // Replace with your GA4 API Secre
-const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+// Telemetry proxy configuration
+const TELEMETRY_PROXY_URL = 'https://telemetry.desktopcommander.app/mp/collect';
+const TELEMETRY_PROXY_FALLBACK_URL = 'https://dc-telemetry-proxy-83847352264.europe-west1.run.app/mp/collect';
 
 // Generate a unique anonymous ID using UUID - consistent with privacy policy
 let uniqueUserId = 'unknown';
@@ -302,11 +301,6 @@ async function enhancedGetTrackingProperties(additionalProps = {}) {
 async function trackEvent(eventName, additionalProps = {}) {
     const trackingStep = addSetupStep(`track_event_${eventName}`);
 
-    if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
-        updateSetupStep(trackingStep, 'skipped', new Error('GA not configured'));
-        return;
-    }
-
     // Add retry capability
     const maxRetries = 2;
     let attempt = 0;
@@ -319,7 +313,7 @@ async function trackEvent(eventName, additionalProps = {}) {
             // Get enriched properties
             const eventProperties = await enhancedGetTrackingProperties(additionalProps);
 
-            // Prepare GA4 payload
+            // Prepare telemetry payload
             const payload = {
                 client_id: uniqueUserId,
                 non_personalized_ads: false,
@@ -330,7 +324,7 @@ async function trackEvent(eventName, additionalProps = {}) {
                 }]
             };
 
-            // Send to Google Analytics
+            // Send to telemetry proxy
             const postData = JSON.stringify(payload);
             
             const options = {
@@ -341,44 +335,8 @@ async function trackEvent(eventName, additionalProps = {}) {
                 }
             };
 
-            const result = await new Promise((resolve, reject) => {
-                const req = https.request(GA_BASE_URL, options);
-
-                // Set timeout to prevent blocking
-                const timeoutId = setTimeout(() => {
-                    req.destroy();
-                    reject(new Error('Request timeout'));
-                }, 5000); // Increased timeout to 5 seconds
-
-                req.on('error', (error) => {
-                    clearTimeout(timeoutId);
-                    reject(error);
-                });
-
-                req.on('response', (res) => {
-                    clearTimeout(timeoutId);
-                    let data = '';
-
-                    res.on('data', (chunk) => {
-                        data += chunk;
-                    });
-
-                    res.on('error', (error) => {
-                        reject(error);
-                    });
-
-                    res.on('end', () => {
-                        if (res.statusCode >= 200 && res.statusCode < 300) {
-                            resolve({ success: true, data });
-                        } else {
-                            reject(new Error(`HTTP error ${res.statusCode}: ${data}`));
-                        }
-                    });
-                });
-
-                req.write(postData);
-                req.end();
-            });
+            const result = await postTelemetryPayload(postData, options);
+            if (!result.success) throw new Error('Telemetry proxy request failed');
 
             updateSetupStep(trackingStep, 'completed');
             return result;
@@ -397,6 +355,54 @@ async function trackEvent(eventName, additionalProps = {}) {
     return false;
 }
 
+async function postTelemetryPayload(postData, options) {
+    for (const endpoint of [TELEMETRY_PROXY_URL, TELEMETRY_PROXY_FALLBACK_URL]) {
+        const result = await new Promise((resolve) => {
+            let settled = false;
+            let timeoutId;
+            const finish = (result) => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeoutId);
+                resolve(result);
+            };
+            const req = https.request(endpoint, options);
+
+            timeoutId = setTimeout(() => {
+                req.destroy();
+                finish({ success: false, data: '' });
+            }, 5000);
+
+            req.on('error', () => {
+                finish({ success: false, data: '' });
+            });
+
+            req.on('response', (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('error', () => {
+                    finish({ success: false, data: '' });
+                });
+                res.on('end', () => {
+                    finish({ success: res.statusCode >= 200 && res.statusCode < 300, data });
+                });
+                res.on('close', () => {
+                    finish({ success: false, data: '' });
+                });
+            });
+
+            req.write(postData);
+            req.end();
+        });
+
+        if (result.success) return result;
+    }
+
+    return { success: false, data: '' };
+}
+
 // Ensure tracking completes before process exits
 async function ensureTrackingCompleted(eventName, additionalProps = {}, timeoutMs = 6000) {
     return new Promise(async (resolve) => {
@@ -933,4 +939,4 @@ if (process.argv.length >= 2 && process.argv[1] === fileURLToPath(import.meta.ur
             process.exit(1);
         }, 1000);
     });
-}
+}

package/dist/terminal-manager.d.ts

@@ -5,7 +5,18 @@ interface CompletedSession {
     exitCode: number | null;
     startTime: Date;
     endTime: Date;
+    evictedLines: number;
+    evictedChars: number;
 }
+/**
+ * Output buffering caps. Without a cap, a process emitting enough output makes
+ * string concatenation throw "RangeError: Invalid string length" at V8's max
+ * string size (~536M chars) inside a stdout 'data' handler — an uncaught
+ * exception that kills the whole server (index.ts exits on uncaughtException).
+ * The cap also bounds the join() cost in snapshot reads and the periodic
+ * process-state scan, both of which are O(total output).
+ */
+export declare const MAX_BUFFERED_OUTPUT_CHARS: number;
 export interface PaginatedOutputResult {
     lines: string[];
     totalLines: number;
@@ -15,6 +26,7 @@ export interface PaginatedOutputResult {
     isComplete: boolean;
     exitCode?: number | null;
     runtimeMs?: number;
+    evictedLines?: number;
 }
 export declare class TerminalManager {
     private sessions;
@@ -72,6 +84,12 @@ export declare class TerminalManager {
         totalChars: number;
         lineCount: number;
     }): string | null;
+    /**
+     * New output since a snapshot, in absolute (since process start) offsets.
+     * If eviction dropped part of the unseen output, returns what the buffer
+     * still holds — the oldest unseen chars are lost to the cap.
+     */
+    private static outputSinceSnapshot;
     /**
    * Get a session by PID
    * @param pid Process ID

package/dist/terminal-manager.js

@@ -4,6 +4,45 @@ import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
 import { capture } from "./utils/capture.js";
 import { analyzeProcessState } from './utils/process-detection.js';
+/**
+ * Standard Windows PATHEXT value, used to repair a corrupted PATHEXT before
+ * spawning child shells.
+ *
+ * On some Windows Claude Desktop / DXT launches the server process inherits a
+ * broken PATHEXT (observed as ".CPL" only). Because we build the child env from
+ * { ...process.env }, that broken value would propagate into every spawned
+ * shell, stripping ".EXE" and breaking resolution of git / node / python / rg /
+ * etc. (and even full-path .exe invocations under PowerShell). See issue #481.
+ */
+const STANDARD_PATHEXT = '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC';
+/**
+ * Return a healthy PATHEXT for spawned Windows shells.
+ * - Unset           -> use the standard list.
+ * - Missing ".EXE"  -> corrupted; merge the standard list with whatever was
+ *                      present (preserves any extra extensions, order-stable).
+ * - Otherwise       -> leave the inherited value untouched.
+ */
+function getRepairedPathExt() {
+    const current = process.env.PATHEXT;
+    if (!current)
+        return STANDARD_PATHEXT;
+    const exts = current.split(';').map(e => e.trim().toUpperCase()).filter(Boolean);
+    if (!exts.includes('.EXE')) {
+        return [...new Set([...STANDARD_PATHEXT.split(';'), ...exts])].join(';');
+    }
+    return current;
+}
+/**
+ * Output buffering caps. Without a cap, a process emitting enough output makes
+ * string concatenation throw "RangeError: Invalid string length" at V8's max
+ * string size (~536M chars) inside a stdout 'data' handler — an uncaught
+ * exception that kills the whole server (index.ts exits on uncaughtException).
+ * The cap also bounds the join() cost in snapshot reads and the periodic
+ * process-state scan, both of which are O(total output).
+ */
+export const MAX_BUFFERED_OUTPUT_CHARS = 50 * 1024 * 1024; // per session; oldest lines evicted first
+const MAX_LINE_CHARS = 1024 * 1024; // force-split longer lines so eviction can work
+const MAX_WAIT_OUTPUT_CHARS = 2 * 1024 * 1024; // start_process wait buffer (prompt/state detection)
 /**
  * Get the appropriate spawn configuration for a given shell
  * This handles login shell flags for different shell types
@@ -39,6 +78,7 @@ function getShellSpawnArgs(shellPath, command) {
         return {
             executable: shellPath,
             args: ['/c', command],
+            windowsVerbatim: true,
             useShellOption: false
         };
     }
@@ -143,6 +183,23 @@ export class TerminalManager {
                 windowsHide: true // Prevent visible console windows on Windows
             };
         }
+        // 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
+        // resolution (git, node, python, rg, ...) in the spawned shell. See #481.
+        if (process.platform === 'win32' && spawnOptions.env) {
+            spawnOptions.env.PATHEXT = getRepairedPathExt();
+        }
+        // On Windows, when we invoke cmd.exe directly and pass the user's command as a
+        // single argument, Node/libuv applies MSVCRT-style quoting that escapes embedded
+        // double quotes as \" . cmd.exe does not understand that escaping, so any command
+        // containing quotes (e.g. a quoted path with spaces like "C:\Program Files\app.exe")
+        // is corrupted before the shell ever parses it. Passing arguments verbatim lets
+        // cmd handle its own quoting. Scoped to shells that set windowsVerbatim (cmd only)
+        // because PowerShell/pwsh have different quote rules and must NOT use verbatim.
+        if (process.platform === 'win32' && spawnConfig.windowsVerbatim) {
+            spawnOptions.windowsVerbatimArguments = true;
+        }
         // Spawn the process with appropriate arguments
         const childProcess = spawn(spawnConfig.executable, spawnConfig.args, spawnOptions);
         let output = '';
@@ -161,7 +218,10 @@ export class TerminalManager {
             outputLines: [], // Line-based buffer
             lastReadIndex: 0, // Track where "new" output starts
             isBlocked: false,
-            startTime: new Date()
+            startTime: new Date(),
+            bufferedChars: 0,
+            evictedLines: 0,
+            evictedChars: 0
         };
         this.sessions.set(childProcess.pid, session);
         // Timing telemetry
@@ -203,7 +263,14 @@ export class TerminalManager {
                 if (!firstOutputTime)
                     firstOutputTime = now;
                 lastOutputTime = now;
-                output += text;
+                // `output` only feeds the wait-phase result and prompt/state detection,
+                // so stop growing it once resolved and keep only a bounded tail.
+                if (!resolved) {
+                    output += text;
+                    if (output.length > MAX_WAIT_OUTPUT_CHARS) {
+                        output = output.slice(-Math.floor(MAX_WAIT_OUTPUT_CHARS / 2));
+                    }
+                }
                 // Append to line-based buffer
                 this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
@@ -236,7 +303,12 @@ export class TerminalManager {
                 if (!firstOutputTime)
                     firstOutputTime = now;
                 lastOutputTime = now;
-                output += text;
+                if (!resolved) {
+                    output += text;
+                    if (output.length > MAX_WAIT_OUTPUT_CHARS) {
+                        output = output.slice(-Math.floor(MAX_WAIT_OUTPUT_CHARS / 2));
+                    }
+                }
                 // Append to line-based buffer
                 this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
@@ -283,7 +355,9 @@ export class TerminalManager {
                         outputLines: [...session.outputLines], // Copy line buffer
                         exitCode: code,
                         startTime: session.startTime,
-                        endTime: new Date()
+                        endTime: new Date(),
+                        evictedLines: session.evictedLines,
+                        evictedChars: session.evictedChars
                     });
                     // Keep only last 100 completed sessions
                     if (this.completedSessions.size > 100) {
@@ -327,6 +401,32 @@ export class TerminalManager {
                 session.outputLines.push(line);
             }
         }
+        // Appended text contributes exactly its length to the joined buffer
+        // (its newlines become the join separators).
+        session.bufferedChars += text.length;
+        // A process printing without newlines grows a single line forever, which
+        // eviction can't bound — force-split so no line exceeds MAX_LINE_CHARS.
+        // Each inserted break adds one separator to the joined length.
+        let lastIndex = session.outputLines.length - 1;
+        while (session.outputLines[lastIndex].length > MAX_LINE_CHARS) {
+            const overlong = session.outputLines[lastIndex];
+            session.outputLines[lastIndex] = overlong.slice(0, MAX_LINE_CHARS);
+            session.outputLines.push(overlong.slice(MAX_LINE_CHARS));
+            session.bufferedChars += 1;
+            lastIndex++;
+        }
+        // Enforce the per-session cap by evicting the oldest lines. Keeps the
+        // buffer far below V8's max string length so concatenation and join()
+        // can never throw "Invalid string length" and kill the server.
+        while (session.bufferedChars > MAX_BUFFERED_OUTPUT_CHARS && session.outputLines.length > 1) {
+            const dropped = session.outputLines.shift();
+            const droppedJoinedChars = dropped.length + 1; // +1 for its join separator
+            session.bufferedChars -= droppedJoinedChars;
+            session.evictedChars += droppedJoinedChars;
+            session.evictedLines++;
+            if (session.lastReadIndex > 0)
+                session.lastReadIndex--;
+        }
     }
     /**
      * Read process output with pagination (like file reading)
@@ -339,15 +439,19 @@ export class TerminalManager {
         // First check active sessions
         const session = this.sessions.get(pid);
         if (session) {
-            return this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
+            const result = this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
+            result.evictedLines = session.evictedLines;
+            return result;
         }
         // Then check completed sessions
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
             const runtimeMs = completedSession.endTime.getTime() - completedSession.startTime.getTime();
-            return this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
+            const result = this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
             () => { }, // No-op for completed sessions
             true, completedSession.exitCode, runtimeMs);
+            result.evictedLines = completedSession.evictedLines;
+            return result;
         }
         return null;
     }
@@ -445,8 +549,11 @@ export class TerminalManager {
         if (session) {
             const fullOutput = session.outputLines.join('\n');
             return {
-                totalChars: fullOutput.length,
-                lineCount: session.outputLines.length
+                // 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;
@@ -460,23 +567,28 @@ export class TerminalManager {
         // Check active session first
         const session = this.sessions.get(pid);
         if (session) {
-            const fullOutput = session.outputLines.join('\n');
-            if (fullOutput.length <= snapshot.totalChars) {
-                return ''; // No new output
-            }
-            return fullOutput.substring(snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(session.outputLines, session.evictedChars, snapshot.totalChars);
         }
         // Fallback to completed sessions - process may have finished between snapshot and poll
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
-            const fullOutput = completedSession.outputLines.join('\n');
-            if (fullOutput.length <= snapshot.totalChars) {
-                return ''; // No new output
-            }
-            return fullOutput.substring(snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(completedSession.outputLines, completedSession.evictedChars, snapshot.totalChars);
         }
         return null;
     }
+    /**
+     * New output since a snapshot, in absolute (since process start) offsets.
+     * 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
+        }
+        return fullOutput.substring(Math.max(0, fullOutput.length - newChars));
+    }
     /**
    * Get a session by PID
    * @param pid Process ID

package/dist/tools/edit.js

@@ -14,8 +14,8 @@
  * 2. Make this file a thin dispatch layer that routes to appropriate FileHandler
  * 3. Unify the editRange() signature to handle both text search/replace and structured edits
  */
-import { writeFile, readFileInternal, validatePath } from './filesystem.js';
-import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
+import { getDefaultEditorMetadata, writeFile, readFileInternal, validatePath } from './filesystem.js';
+import { runFuzzySearchInWorker, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { EditBlockArgsSchema } from "./schemas.js";
@@ -180,6 +180,8 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
                 fileName: path.basename(resolvedEditPath),
                 filePath: resolvedEditPath,
                 fileType: resolvePreviewFileType(resolvedEditPath),
+                sourceTool: 'edit_block',
+                ...await getDefaultEditorMetadata(resolvedEditPath),
             },
         };
     }
@@ -200,8 +202,9 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
     if (count === 0) {
         // Track fuzzy search time
         const startTime = performance.now();
-        // Perform fuzzy search
-        const fuzzyResult = recursiveFuzzyIndexOf(content, block.search);
+        // Perform fuzzy search in a worker thread so the main event loop stays
+        // responsive to pings and parallel tool calls during the scan
+        const fuzzyResult = await runFuzzySearchInWorker(content, block.search);
         const similarity = getSimilarityRatio(block.search, fuzzyResult.value);
         // Calculate execution time in milliseconds
         const executionTime = performance.now() - startTime;
@@ -368,6 +371,8 @@ export async function handleEditBlock(args) {
                         fileName: path.basename(resolvedRangePath),
                         filePath: resolvedRangePath,
                         fileType: resolvePreviewFileType(resolvedRangePath),
+                        sourceTool: 'edit_block',
+                        ...await getDefaultEditorMetadata(resolvedRangePath),
                     },
                 };
             }
@@ -403,6 +408,8 @@ export async function handleEditBlock(args) {
                         fileName: path.basename(resolvedEditRangePath),
                         filePath: resolvedEditRangePath,
                         fileType: resolvePreviewFileType(resolvedEditRangePath),
+                        sourceTool: 'edit_block',
+                        ...await getDefaultEditorMetadata(resolvedEditRangePath),
                     },
                 };
             }

package/dist/tools/filesystem.d.ts

@@ -71,3 +71,8 @@ export declare function getFileInfo(filePath: string): Promise<Record<string, an
  * @param options Options for PDF generation or modification. For modification, can include `sourcePdf`.
  */
 export declare function writePdf(filePath: string, content: string | PdfOperations[], outputPath?: string, options?: any): Promise<void>;
+type DefaultEditorMetadata = {
+    defaultEditorName?: string;
+    defaultEditorPath?: string;
+};
+export declare function getDefaultEditorMetadata(filePath: string): Promise<DefaultEditorMetadata>;

package/dist/tools/filesystem.js

@@ -2,6 +2,8 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { capture } from '../utils/capture.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
@@ -887,3 +889,44 @@ export async function writePdf(filePath, content, outputPath, options = {}) {
         throw new Error('Invalid content type for writePdf. Expected string (markdown) or array of operations.');
     }
 }
+const execFileAsync = promisify(execFile);
+const DEFAULT_EDITOR_NEGATIVE_CACHE_MS = 5 * 60 * 1000;
+const defaultEditorCache = new Map();
+function escapeAppleScriptString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export async function getDefaultEditorMetadata(filePath) {
+    if (os.platform() !== 'darwin') {
+        return {};
+    }
+    let cacheKey = '';
+    try {
+        const extension = path.extname(filePath).toLowerCase();
+        cacheKey = extension || path.basename(filePath).toLowerCase();
+        const cached = defaultEditorCache.get(cacheKey);
+        if (cached) {
+            if (!cached.expiresAt || cached.expiresAt > Date.now()) {
+                return cached.metadata;
+            }
+            defaultEditorCache.delete(cacheKey);
+        }
+        const script = `set appAlias to default application of (info for POSIX file "${escapeAppleScriptString(filePath)}")\nreturn (name of (info for appAlias)) & linefeed & POSIX path of appAlias`;
+        const { stdout } = await execFileAsync('osascript', ['-e', script], { timeout: 12000 });
+        const lines = stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+        const defaultEditorName = lines[lines.length - 2]?.replace(/\.app$/i, '') ?? '';
+        const defaultEditorPath = lines[lines.length - 1] ?? '';
+        if (defaultEditorName && defaultEditorPath.startsWith('/')) {
+            const metadata = { defaultEditorName, defaultEditorPath };
+            defaultEditorCache.set(cacheKey, { metadata });
+            return metadata;
+        }
+        defaultEditorCache.set(cacheKey, { metadata: {}, expiresAt: Date.now() + DEFAULT_EDITOR_NEGATIVE_CACHE_MS });
+    }
+    catch {
+        if (cacheKey) {
+            defaultEditorCache.set(cacheKey, { metadata: {}, expiresAt: Date.now() + DEFAULT_EDITOR_NEGATIVE_CACHE_MS });
+        }
+        // Generic UI fallback is good enough if detection fails.
+    }
+    return {};
+}

package/dist/tools/fuzzySearch.d.ts

@@ -1,22 +1,12 @@
+import type { FuzzyMatch } from './fuzzySearchCore.js';
+export { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearchCore.js';
+/** Abort fuzzy search in the worker after this many ms to avoid unbounded CPU burn. */
+export declare 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
+ * 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.
  */
-export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number, depth?: number): {
-    start: number;
-    end: number;
-    value: string;
-    distance: number;
-};
-/**
- * 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;
+export declare function runFuzzySearchInWorker(text: string, query: string, timeoutMs?: number): Promise<FuzzyMatch>;