@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/polyform-license-src/edit/edit.js

@@ -0,0 +1,163 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { readFile, writeFile } from '../../tools/filesystem.js';
+import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
+import { capture } from '../../utils.js';
+/**
+ * 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."
+                }],
+        };
+    }
+    // Read file as plain string
+    const { content } = await readFile(filePath);
+    // Make sure content is a string
+    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: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}`
+                }],
+        };
+    }
+    // If exact match found but count doesn't match expected, inform the user
+    if (count > 0 && count !== expectedReplacements) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Expected ${expectedReplacements} occurrences but found ${count} in ${filePath}. ` +
+                        `If you want to replace all ${count} occurrences, set expected_replacements to ${count}. ` +
+                        `If you want to replace a specific occurrence, make your search string more unique by adding context.`
+                }],
+        };
+    }
+    // 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,
+                file_path: filePath,
+                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}`;
+}

package/dist/polyform-license-src/edit/fuzzySearch.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+/**
+ * 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, 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;

package/dist/polyform-license-src/edit/fuzzySearch.js

@@ -0,0 +1,121 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { distance } from 'fastest-levenshtein';
+import { capture } from '../../utils.js';
+/**
+ * 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, 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);
+    }
+}
+/**
+ * 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;
+    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
+    });
+    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/polyform-license-src/edit/handlers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { ServerResult } from '../../types.js';
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export declare function handleEnhancedEditBlock(args: unknown): Promise<ServerResult>;

package/dist/polyform-license-src/edit/handlers.js

@@ -0,0 +1,24 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { performSearchReplace } from './edit.js';
+import { EditBlockArgsSchema } from './schemas.js';
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export async function handleEnhancedEditBlock(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/polyform-license-src/edit/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+export * from './edit.js';
+export * from './fuzzySearch.js';
+export * from './handlers.js';
+export * from './schemas.js';

package/dist/polyform-license-src/edit/index.js

@@ -0,0 +1,13 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+// Export all enhanced edit functionality
+export * from './edit.js';
+export * from './fuzzySearch.js';
+export * from './handlers.js';
+export * from './schemas.js';

package/dist/polyform-license-src/edit/schemas.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { z } from 'zod';
+export declare const EditBlockArgsSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    expected_replacements: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements: number;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements?: number | undefined;
+}>;

package/dist/polyform-license-src/edit/schemas.js

@@ -0,0 +1,16 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+import { z } from 'zod';
+// Enhanced edit block schema with separate parameters for clarity
+export const EditBlockArgsSchema = z.object({
+    file_path: z.string(),
+    old_string: z.string(),
+    new_string: z.string(),
+    expected_replacements: z.number().optional().default(1),
+});

package/dist/polyform-license-src/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+export * from './edit/index.js';

package/dist/polyform-license-src/index.js

@@ -0,0 +1,10 @@
+/**
+ * SPDX-License-Identifier: PolyForm-Small-Business-1.0.0
+ *
+ * Copyright (c) 2025 Desktope Commander MCP Contributors
+ *
+ * This file is licensed under the PolyForm Small Business License 1.0.0
+ * See the LICENSE file in the /src/polyform directory for the full license text.
+ */
+// Export all PolyForm-licensed functionality
+export * from './edit/index.js';

package/dist/sandbox/index.d.ts

@@ -0,0 +1,9 @@
+import { CommandExecutionResult } from '../types.js';
+/**
+ * Platform detection and sandbox execution router
+ */
+export declare function executeSandboxedCommand(command: string, timeoutMs?: number, shell?: string): Promise<CommandExecutionResult>;
+/**
+ * Check if sandboxed execution is available for the current platform
+ */
+export declare function isSandboxAvailable(): boolean;

package/dist/sandbox/index.js

@@ -0,0 +1,50 @@
+import os from 'os';
+import { executeSandboxedCommand as macExecuteSandboxedCommand } from './mac-sandbox.js';
+import { configManager } from '../config-manager.js';
+/**
+ * Platform detection and sandbox execution router
+ */
+export async function executeSandboxedCommand(command, timeoutMs = 30000, shell) {
+    // Get the allowed directories from config
+    const config = await configManager.getConfig();
+    const allowedDirectories = config.allowedDirectories || [os.homedir()];
+    const platform = os.platform();
+    // Platform-specific sandbox execution
+    switch (platform) {
+        case 'darwin': // macOS
+            try {
+                const result = await macExecuteSandboxedCommand(command, allowedDirectories, timeoutMs);
+                return {
+                    pid: result.pid,
+                    output: result.output,
+                    isBlocked: result.isBlocked
+                };
+            }
+            catch (error) {
+                console.error('Mac sandbox execution error:', error);
+                return {
+                    pid: -1,
+                    output: `Sandbox execution error: ${error instanceof Error ? error.message : String(error)}`,
+                    isBlocked: false
+                };
+            }
+        // Add cases for other platforms when implemented
+        // case 'linux':
+        // case 'win32':
+        default:
+            // For unsupported platforms, return an error
+            return {
+                pid: -1,
+                output: `Sandbox execution not supported on ${platform}. Command was not executed: ${command}`,
+                isBlocked: false
+            };
+    }
+}
+/**
+ * Check if sandboxed execution is available for the current platform
+ */
+export function isSandboxAvailable() {
+    const platform = os.platform();
+    // Currently only implemented for macOS
+    return platform === 'darwin';
+}

package/dist/sandbox/mac-sandbox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generate a temporary sandbox profile for macOS that restricts access to allowed directories
+ * @param allowedDirectories Array of directories that should be accessible
+ * @returns Path to the generated sandbox profile file
+ */
+export declare function generateSandboxProfile(allowedDirectories: string[]): Promise<string>;
+/**
+ * Execute a command in a macOS sandbox with access restricted to allowed directories
+ * @param command Command to execute
+ * @param allowedDirectories Array of allowed directory paths
+ * @param options Additional execution options
+ * @returns Promise resolving to the execution result
+ */
+export declare function executeSandboxedCommand(command: string, allowedDirectories: string[], timeoutMs?: number): Promise<{
+    output: string;
+    exitCode: number | null;
+    isBlocked: boolean;
+    pid: number;
+}>;