@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/terminal-manager.d.ts

@@ -9,7 +9,7 @@ interface CompletedSession {
 export declare class TerminalManager {
     private sessions;
     private completedSessions;
-    executeCommand(command: string, timeoutMs?: number): Promise<CommandExecutionResult>;
+    executeCommand(command: string, timeoutMs?: number, shell?: string): Promise<CommandExecutionResult>;
     getNewOutput(pid: number): string | null;
     forceTerminate(pid: number): boolean;
     listActiveSessions(): ActiveSession[];

package/dist/terminal-manager.js

@@ -1,12 +1,29 @@
 import { spawn } from 'child_process';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
+import { configManager } from './config-manager.js';
+import { capture } from "./utils/capture.js";
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.completedSessions = new Map();
     }
-    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
-        const process = spawn(command, [], { shell: true });
+    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell) {
+        // Get the shell from config if not specified
+        let shellToUse = shell;
+        if (!shellToUse) {
+            try {
+                const config = await configManager.getConfig();
+                shellToUse = config.shell || true;
+            }
+            catch (error) {
+                // If there's an error getting the config, fall back to default
+                shellToUse = true;
+            }
+        }
+        const spawnOptions = {
+            shell: shellToUse
+        };
+        const process = spawn(command, [], spawnOptions);
         let output = '';
         // Ensure process.pid is defined before proceeding
         if (!process.pid) {
@@ -101,7 +118,9 @@ export class TerminalManager {
             return true;
         }
         catch (error) {
-            console.error(`Failed to terminate process ${pid}:`, error);
+            // Convert error to string, handling both Error objects and other types
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            capture('server_request_error', { error: errorMessage, message: `Failed to terminate process ${pid}:` });
             return false;
         }
     }

package/dist/tools/config.d.ts

@@ -1,29 +1,3 @@
-import { z } from 'zod';
-export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const GetConfigValueArgsSchema: z.ZodObject<{
-    key: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-}, {
-    key: string;
-}>;
-export declare const SetConfigValueArgsSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    value?: any;
-}, {
-    key: string;
-    value?: any;
-}>;
-export declare const UpdateConfigArgsSchema: z.ZodObject<{
-    config: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    config: Record<string, any>;
-}, {
-    config: Record<string, any>;
-}>;
 /**
  * Get the entire config
  */
@@ -33,22 +7,6 @@ export declare function getConfig(): Promise<{
         text: string;
     }[];
 }>;
-/**
- * Get a specific config value
- */
-export declare function getConfigValue(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;
 /**
  * Set a specific config value
  */
@@ -65,19 +23,3 @@ export declare function setConfigValue(args: unknown): Promise<{
     }[];
     isError?: undefined;
 }>;
-/**
- * Update multiple config values at once
- */
-export declare function updateConfig(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;

package/dist/tools/config.js

@@ -1,17 +1,5 @@
-import { z } from 'zod';
 import { configManager } from '../config-manager.js';
-// Schemas for config operations
-export const GetConfigArgsSchema = z.object({});
-export const GetConfigValueArgsSchema = z.object({
-    key: z.string(),
-});
-export const SetConfigValueArgsSchema = z.object({
-    key: z.string(),
-    value: z.any(),
-});
-export const UpdateConfigArgsSchema = z.object({
-    config: z.record(z.any()),
-});
+import { SetConfigValueArgsSchema } from './schemas.js';
 /**
  * Get the entire config
  */
@@ -39,46 +27,6 @@ export async function getConfig() {
         };
     }
 }
-/**
- * Get a specific config value
- */
-export async function getConfigValue(args) {
-    console.error(`getConfigValue called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = GetConfigValueArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for get_config_value: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        const value = await configManager.getValue(parsed.data.key);
-        console.error(`getConfigValue result for key ${parsed.data.key}: ${JSON.stringify(value)}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: value !== undefined
-                        ? `Value for ${parsed.data.key}: ${JSON.stringify(value, null, 2)}`
-                        : `No value found for key: ${parsed.data.key}`
-                }],
-        };
-    }
-    catch (error) {
-        console.error(`Error in getConfigValue: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error retrieving value: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}
 /**
  * Set a specific config value
  */
@@ -97,12 +45,52 @@ export async function setConfigValue(args) {
             };
         }
         try {
-            await configManager.setValue(parsed.data.key, parsed.data.value);
-            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value)}`);
+            // Parse string values that should be arrays or objects
+            let valueToStore = parsed.data.value;
+            // If the value is a string that looks like an array or object, try to parse it
+            if (typeof valueToStore === 'string' &&
+                (valueToStore.startsWith('[') || valueToStore.startsWith('{'))) {
+                try {
+                    valueToStore = JSON.parse(valueToStore);
+                    console.error(`Parsed string value to object/array: ${JSON.stringify(valueToStore)}`);
+                }
+                catch (parseError) {
+                    console.error(`Failed to parse string as JSON, using as-is: ${parseError}`);
+                }
+            }
+            // Special handling for known array configuration keys
+            if ((parsed.data.key === 'allowedDirectories' || parsed.data.key === 'blockedCommands') &&
+                !Array.isArray(valueToStore)) {
+                if (typeof valueToStore === 'string') {
+                    try {
+                        valueToStore = JSON.parse(valueToStore);
+                    }
+                    catch (parseError) {
+                        console.error(`Failed to parse string as array for ${parsed.data.key}: ${parseError}`);
+                        // If parsing failed and it's a single value, convert to an array with one item
+                        if (!valueToStore.includes('[')) {
+                            valueToStore = [valueToStore];
+                        }
+                    }
+                }
+                else {
+                    // If not a string or array, convert to an array with one item
+                    valueToStore = [valueToStore];
+                }
+                // Ensure the value is an array after all our conversions
+                if (!Array.isArray(valueToStore)) {
+                    console.error(`Value for ${parsed.data.key} is still not an array, converting to array`);
+                    valueToStore = [String(valueToStore)];
+                }
+            }
+            await configManager.setValue(parsed.data.key, valueToStore);
+            // Get the updated configuration to show the user
+            const updatedConfig = await configManager.getConfig();
+            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore)}`);
             return {
                 content: [{
                         type: "text",
-                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value, null, 2)}`
+                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore, null, 2)}\n\nUpdated configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
                     }],
             };
         }
@@ -130,54 +118,3 @@ export async function setConfigValue(args) {
         };
     }
 }
-/**
- * Update multiple config values at once
- */
-export async function updateConfig(args) {
-    console.error(`updateConfig called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = UpdateConfigArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for update_config: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        try {
-            const updatedConfig = await configManager.updateConfig(parsed.data.config);
-            console.error(`updateConfig result: ${JSON.stringify(updatedConfig, null, 2)}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated successfully.\nNew configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
-                    }],
-            };
-        }
-        catch (saveError) {
-            console.error(`Error saving updated config: ${saveError.message}`);
-            // Return useful response instead of crashing
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated in memory but couldn't be saved to disk: ${saveError.message}`
-                    }],
-                isError: true
-            };
-        }
-    }
-    catch (error) {
-        console.error(`Error in updateConfig: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error updating configuration: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}

package/dist/tools/debug-path.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/debug-path.js

@@ -0,0 +1,44 @@
+// This is a debug script to help understand how ~ expansion works
+import os from 'os';
+import path from 'path';
+function expandHome(filepath) {
+    console.log(`Expanding ${filepath}`);
+    // Handle both '~' alone or '~/' path prefix
+    if (filepath === '~') {
+        const home = os.homedir();
+        console.log(`~ expanded to ${home}`);
+        return home;
+    }
+    else if (filepath.startsWith('~/')) {
+        const joinedPath = path.join(os.homedir(), filepath.slice(2));
+        console.log(`~/ expanded to ${joinedPath}`);
+        return joinedPath;
+    }
+    return filepath;
+}
+console.log(`Home directory: ${os.homedir()}`);
+console.log(`Current working directory: ${process.cwd()}`);
+console.log(`Expanding ~: ${expandHome('~')}`);
+console.log(`Expanding ~/Documents: ${expandHome('~/Documents')}`);
+console.log(`Expanding /tmp: ${expandHome('/tmp')}`);
+// Create lowercase normalized paths for comparison
+function normalizePath(p) {
+    return path.normalize(p).toLowerCase();
+}
+const allowedDir = '~';
+const expandedAllowedDir = expandHome(allowedDir);
+const normalizedAllowedDir = normalizePath(expandedAllowedDir);
+console.log(`Allowed dir: ${allowedDir}`);
+console.log(`Expanded allowed dir: ${expandedAllowedDir}`);
+console.log(`Normalized allowed dir: ${normalizedAllowedDir}`);
+// Example path to check
+const pathToCheck = '~';
+const expandedPathToCheck = expandHome(pathToCheck);
+const normalizedPathToCheck = normalizePath(expandedPathToCheck);
+console.log(`Path to check: ${pathToCheck}`);
+console.log(`Expanded path to check: ${expandedPathToCheck}`);
+console.log(`Normalized path to check: ${normalizedPathToCheck}`);
+// Check if path is allowed
+const isAllowed = normalizedPathToCheck === normalizedAllowedDir ||
+    normalizedPathToCheck.startsWith(normalizedAllowedDir + path.sep);
+console.log(`Is path allowed: ${isAllowed}`);

package/dist/tools/edit.d.ts

@@ -3,10 +3,12 @@ interface SearchReplace {
     search: string;
     replace: string;
 }
-export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<ServerResult>;
-export declare function parseEditBlock(blockContent: string): Promise<{
-    filePath: string;
-    searchReplace: SearchReplace;
-    error?: string;
-}>;
+export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number): Promise<ServerResult>;
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
 export {};

package/dist/tools/edit.js

@@ -1,45 +1,175 @@
 import { readFile, writeFile } from './filesystem.js';
-export async function performSearchReplace(filePath, block) {
-    // Read file as plain string (don't pass true to get just the string)
-    const content = await readFile(filePath);
+import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
+import { capture } from '../utils/capture.js';
+import { EditBlockArgsSchema } from "./schemas.js";
+import path from 'path';
+/**
+ * Threshold for fuzzy matching - similarity must be at least this value to be considered
+ * (0-1 scale where 1 is perfect match and 0 is completely different)
+ */
+const FUZZY_THRESHOLD = 0.7;
+export async function performSearchReplace(filePath, block, expectedReplacements = 1) {
+    // Check for empty search string to prevent infinite loops
+    if (block.search === "") {
+        return {
+            content: [{
+                    type: "text",
+                    text: "Empty search strings are not allowed. Please provide a non-empty string to search for."
+                }],
+        };
+    }
+    // Get file extension for telemetry using path module
+    const fileExtension = path.extname(filePath).toLowerCase();
+    // Capture file extension in telemetry without capturing the file path
+    capture('server_edit_block', { fileExtension: fileExtension });
+    // Read file as plain string
+    const { content } = await readFile(filePath);
     // Make sure content is a string
-    const contentStr = typeof content === 'string' ? content : content.content;
-    // Find first occurrence
-    const searchIndex = contentStr.indexOf(block.search);
-    if (searchIndex === -1) {
+    if (typeof content !== 'string') {
+        throw new Error('Wrong content for file ' + filePath);
+    }
+    // First try exact match
+    let tempContent = content;
+    let count = 0;
+    let pos = tempContent.indexOf(block.search);
+    while (pos !== -1) {
+        count++;
+        pos = tempContent.indexOf(block.search, pos + 1);
+    }
+    // If exact match found and count matches expected replacements, proceed with exact replacement
+    if (count > 0 && count === expectedReplacements) {
+        // Replace all occurrences
+        let newContent = content;
+        // If we're only replacing one occurrence, replace it directly
+        if (expectedReplacements === 1) {
+            const searchIndex = newContent.indexOf(block.search);
+            newContent =
+                newContent.substring(0, searchIndex) +
+                    block.replace +
+                    newContent.substring(searchIndex + block.search.length);
+        }
+        else {
+            // Replace all occurrences using split and join for multiple replacements
+            newContent = newContent.split(block.search).join(block.replace);
+        }
+        await writeFile(filePath, newContent);
         return {
-            content: [{ type: "text", text: `Search content not found in ${filePath}.` }],
+            content: [{
+                    type: "text",
+                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}`
+                }],
         };
     }
-    // Replace content
-    const newContent = contentStr.substring(0, searchIndex) +
-        block.replace +
-        contentStr.substring(searchIndex + block.search.length);
-    await writeFile(filePath, newContent);
-    return {
-        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-    };
-}
-export async function parseEditBlock(blockContent) {
-    const lines = blockContent.split('\n');
-    // First line should be the file path
-    const filePath = lines[0].trim();
-    // Find the markers
-    const searchStart = lines.indexOf('<<<<<<< SEARCH');
-    const divider = lines.indexOf('=======');
-    const replaceEnd = lines.indexOf('>>>>>>> REPLACE');
-    if (searchStart === -1 || divider === -1 || replaceEnd === -1) {
+    // If exact match found but count doesn't match expected, inform the user
+    if (count > 0 && count !== expectedReplacements) {
         return {
-            filePath: '',
-            searchReplace: { search: '', replace: '' },
-            error: 'Invalid edit block format - missing markers'
+            content: [{
+                    type: "text",
+                    text: `Expected ${expectedReplacements} occurrences but found ${count} in ${filePath}. ` +
+                        `Double check and make sure you understand all occurencies and if you want to replace all ${count} occurrences, set expected_replacements to ${count}. ` +
+                        `If there are many occurrancies and you want to change some of them and keep the rest. Do it one by one, by adding more lines around each occurrence.` +
+                        `If you want to replace a specific occurrence, make your search string more unique by adding more lines around search string.`
+                }],
         };
     }
-    // Extract search and replace content
-    const search = lines.slice(searchStart + 1, divider).join('\n');
-    const replace = lines.slice(divider + 1, replaceEnd).join('\n');
-    return {
-        filePath,
-        searchReplace: { search, replace }
+    // If exact match not found, try fuzzy search
+    if (count === 0) {
+        // Track fuzzy search time
+        const startTime = performance.now();
+        // Perform fuzzy search
+        const fuzzyResult = recursiveFuzzyIndexOf(content, block.search);
+        const similarity = getSimilarityRatio(block.search, fuzzyResult.value);
+        // Calculate execution time in milliseconds
+        const executionTime = performance.now() - startTime;
+        // Check if the fuzzy match is "close enough"
+        if (similarity >= FUZZY_THRESHOLD) {
+            // Format differences for clearer output
+            const diff = highlightDifferences(block.search, fuzzyResult.value);
+            // Capture the fuzzy search event
+            capture('server_fuzzy_search_performed', {
+                similarity: similarity,
+                execution_time_ms: executionTime,
+                search_length: block.search.length,
+                file_size: content.length,
+                threshold: FUZZY_THRESHOLD,
+                found_text_length: fuzzyResult.value.length
+            });
+            // If we allow fuzzy matches, we would make the replacement here
+            // For now, we'll return a detailed message about the fuzzy match
+            return {
+                content: [{
+                        type: "text",
+                        text: `Exact match not found, but found a similar text with ${Math.round(similarity * 100)}% similarity (found in ${executionTime.toFixed(2)}ms):\n\n` +
+                            `Differences:\n${diff}\n\n` +
+                            `To replace this text, use the exact text found in the file.`
+                    }],
+            };
+        }
+        else {
+            // If the fuzzy match isn't close enough
+            // Still capture the fuzzy search event even for unsuccessful matches
+            capture('server_fuzzy_search_performed', {
+                similarity: similarity,
+                execution_time_ms: executionTime,
+                search_length: block.search.length,
+                file_size: content.length,
+                threshold: FUZZY_THRESHOLD,
+                found_text_length: fuzzyResult.value.length,
+                below_threshold: true
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search content not found in ${filePath}. The closest match was "${fuzzyResult.value}" ` +
+                            `with only ${Math.round(similarity * 100)}% similarity, which is below the ${Math.round(FUZZY_THRESHOLD * 100)}% threshold. ` +
+                            `(Fuzzy search completed in ${executionTime.toFixed(2)}ms)`
+                    }],
+            };
+        }
+    }
+    throw new Error("Unexpected error during search and replace operation.");
+}
+/**
+ * Generates a character-level diff using standard {-removed-}{+added+} format
+ * @param expected The string that was searched for
+ * @param actual The string that was found
+ * @returns A formatted string showing character-level differences
+ */
+function highlightDifferences(expected, actual) {
+    // Implementation of a simplified character-level diff
+    // Find common prefix and suffix
+    let prefixLength = 0;
+    const minLength = Math.min(expected.length, actual.length);
+    // Determine common prefix length
+    while (prefixLength < minLength &&
+        expected[prefixLength] === actual[prefixLength]) {
+        prefixLength++;
+    }
+    // Determine common suffix length
+    let suffixLength = 0;
+    while (suffixLength < minLength - prefixLength &&
+        expected[expected.length - 1 - suffixLength] === actual[actual.length - 1 - suffixLength]) {
+        suffixLength++;
+    }
+    // Extract the common and different parts
+    const commonPrefix = expected.substring(0, prefixLength);
+    const commonSuffix = expected.substring(expected.length - suffixLength);
+    const expectedDiff = expected.substring(prefixLength, expected.length - suffixLength);
+    const actualDiff = actual.substring(prefixLength, actual.length - suffixLength);
+    // Format the output as a character-level diff
+    return `${commonPrefix}{-${expectedDiff}-}{+${actualDiff}+}${commonSuffix}`;
+}
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export async function handleEditBlock(args) {
+    const parsed = EditBlockArgsSchema.parse(args);
+    const searchReplace = {
+        search: parsed.old_string,
+        replace: parsed.new_string
     };
+    return performSearchReplace(parsed.file_path, searchReplace, parsed.expected_replacements);
 }

package/dist/tools/execute.js

@@ -1,7 +1,7 @@
 import { terminalManager } from '../terminal-manager.js';
 import { commandManager } from '../command-manager.js';
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
-import { capture } from "../utils.js";
+import { capture } from "../utils/capture.js";
 export async function executeCommand(args) {
     const parsed = ExecuteCommandArgsSchema.safeParse(args);
     if (!parsed.success) {
@@ -13,7 +13,7 @@ export async function executeCommand(args) {
     }
     try {
         // Extract all commands for analytics while ensuring execution continues even if parsing fails
-        const commands = commandManager.extractCommands(parsed.data.command);
+        const commands = commandManager.extractCommands(parsed.data.command).join(', ');
         capture('server_execute_command', {
             command: commandManager.getBaseCommand(parsed.data.command), // Keep original for backward compatibility
             commands: commands // Add the array of all identified commands
@@ -24,16 +24,16 @@ export async function executeCommand(args) {
         capture('server_execute_command', {
             command: commandManager.getBaseCommand(parsed.data.command)
         });
-        // Log the error but continue execution
-        console.error('Error during command extraction:', error);
     }
-    if (!commandManager.validateCommand(parsed.data.command)) {
+    // Command validation is now async
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
         return {
             content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
             isError: true,
         };
     }
-    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms);
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, parsed.data.shell);
     // Check for error condition (pid = -1)
     if (result.pid === -1) {
         return {

package/dist/tools/filesystem-fixed.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read a file from either the local filesystem or a URL
+ * @param filePath Path to the file or URL
+ * @param returnMetadata Whether to return metadata with the content
+ * @param isUrl Whether the path is a URL
+ * @returns File content or file result with metadata
+ */
+export declare function readFile(filePath: string, returnMetadata?: boolean, isUrl?: boolean): Promise<string | FileResult>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export interface MultiFileResult {
+    path: string;
+    content?: string;
+    mimeType?: string;
+    isImage?: boolean;
+    error?: string;
+}
+export declare function readMultipleFiles(paths: string[]): Promise<MultiFileResult[]>;
+export declare function createDirectory(dirPath: string): Promise<void>;
+export declare function listDirectory(dirPath: string): Promise<string[]>;
+export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;
+export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
+export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;