@wonderwhy-er/desktop-commander 0.1.39 → 0.2.1

package/dist/tools/filesystem.js

@@ -208,38 +208,41 @@ export async function readFileFromUrl(url) {
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
- * @param returnMetadata Whether to return metadata with the content
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export async function readFileFromDisk(filePath) {
+export async function readFileFromDisk(filePath, offset = 0, length) {
+    // Add validation for required parameters
+    if (!filePath || typeof filePath !== 'string') {
+        throw new Error('Invalid file path provided');
+    }
     // Import the MIME type utilities
     const { getMimeType, isImageFile } = await import('./mime-types.js');
+    // Get default length from config if not provided
+    if (length === undefined) {
+        const config = await configManager.getConfig();
+        length = config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
+    }
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry using path module consistently
     const fileExtension = path.extname(validPath).toLowerCase();
     // Check file size before attempting to read
     try {
         const stats = await fs.stat(validPath);
-        const MAX_SIZE = 100 * 1024; // 100KB limit
-        if (stats.size > MAX_SIZE) {
-            const message = `File too large (${(stats.size / 1024).toFixed(2)}KB > ${MAX_SIZE / 1024}KB limit)`;
-            // Capture file extension in telemetry without capturing the file path
-            capture('server_read_file_large', { fileExtension: fileExtension });
-            return {
-                content: message,
-                mimeType: 'text/plain',
-                isImage: false
-            };
-        }
         // Capture file extension in telemetry without capturing the file path
-        capture('server_read_file', { fileExtension: fileExtension });
+        capture('server_read_file', {
+            fileExtension: fileExtension,
+            offset: offset,
+            length: length,
+            fileSize: stats.size
+        });
     }
     catch (error) {
         console.error('error catch ' + error);
         const errorMessage = error instanceof Error ? error.message : String(error);
         capture('server_read_file_error', { error: errorMessage, fileExtension: fileExtension });
         // If we can't stat the file, continue anyway and let the read operation handle errors
-        //console.error(`Failed to stat file ${validPath}:`, error);
     }
     // Detect the MIME type based on file extension
     const mimeType = getMimeType(validPath);
@@ -249,15 +252,47 @@ export async function readFileFromDisk(filePath) {
     const readOperation = async () => {
         if (isImage) {
             // For image files, read as Buffer and convert to base64
+            // Images are always read in full, ignoring offset and length
             const buffer = await fs.readFile(validPath);
             const content = buffer.toString('base64');
             return { content, mimeType, isImage };
         }
         else {
-            // For all other files, try to read as UTF-8 text
+            // For all other files, try to read as UTF-8 text with line-based offset and length
             try {
+                // Read the entire file first
                 const buffer = await fs.readFile(validPath);
-                const content = buffer.toString('utf-8');
+                const fullContent = buffer.toString('utf-8');
+                // Split into lines for line-based access
+                const lines = fullContent.split('\n');
+                const totalLines = lines.length;
+                // Apply line-based offset and length - handle beyond-file-size scenario
+                let startLine = Math.min(offset, totalLines);
+                let endLine = Math.min(startLine + length, totalLines);
+                // If startLine equals totalLines (reading beyond end), adjust to show some content
+                // Only do this if we're not trying to read the whole file
+                if (startLine === totalLines && offset > 0 && length < Number.MAX_SAFE_INTEGER) {
+                    // Show last few lines instead of nothing
+                    const lastLinesCount = Math.min(10, totalLines); // Show last 10 lines or fewer if file is smaller
+                    startLine = Math.max(0, totalLines - lastLinesCount);
+                    endLine = totalLines;
+                }
+                const selectedLines = lines.slice(startLine, endLine);
+                const truncatedContent = selectedLines.join('\n');
+                // Add an informational message if truncated or adjusted
+                let content = truncatedContent;
+                // Only add informational message for normal reads (not when reading entire file)
+                const isEntireFileRead = offset === 0 && length >= Number.MAX_SAFE_INTEGER;
+                if (!isEntireFileRead) {
+                    if (offset >= totalLines && totalLines > 0) {
+                        // Reading beyond end of file case
+                        content = `[NOTICE: Offset ${offset} exceeds file length (${totalLines} lines). Showing last ${endLine - startLine} lines instead.]\n\n${truncatedContent}`;
+                    }
+                    else if (offset > 0 || endLine < totalLines) {
+                        // Normal partial read case
+                        content = `[Reading ${endLine - startLine} lines from line ${startLine} of ${totalLines} total lines]\n\n${truncatedContent}`;
+                    }
+                }
                 return { content, mimeType, isImage };
             }
             catch (error) {
@@ -279,22 +314,37 @@ export async function readFileFromDisk(filePath) {
 /**
  * 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
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export async function readFile(filePath, isUrl) {
+export async function readFile(filePath, isUrl, offset, length) {
     return isUrl
         ? readFileFromUrl(filePath)
-        : readFileFromDisk(filePath);
+        : readFileFromDisk(filePath, offset, length);
 }
-export async function writeFile(filePath, content) {
+export async function writeFile(filePath, content, mode = 'rewrite') {
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry
     const fileExtension = path.extname(validPath).toLowerCase();
-    // Capture file extension in telemetry without capturing the file path
-    capture('server_write_file', { fileExtension: fileExtension });
-    await fs.writeFile(validPath, content);
+    // Calculate content metrics
+    const contentBytes = Buffer.from(content).length;
+    const lineCount = content.split('\n').length;
+    // Capture file extension and operation details in telemetry without capturing the file path
+    capture('server_write_file', {
+        fileExtension: fileExtension,
+        mode: mode,
+        contentBytes: contentBytes,
+        lineCount: lineCount
+    });
+    // Use different fs methods based on mode
+    if (mode === 'append') {
+        await fs.appendFile(validPath, content);
+    }
+    else {
+        await fs.writeFile(validPath, content);
+    }
 }
 export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {
@@ -388,7 +438,8 @@ export async function searchFiles(rootPath, pattern) {
 export async function getFileInfo(filePath) {
     const validPath = await validatePath(filePath);
     const stats = await fs.stat(validPath);
-    return {
+    // Basic file info
+    const info = {
         size: stats.size,
         created: stats.birthtime,
         modified: stats.mtime,
@@ -397,6 +448,27 @@ export async function getFileInfo(filePath) {
         isFile: stats.isFile(),
         permissions: stats.mode.toString(8).slice(-3),
     };
+    // For text files that aren't too large, also count lines
+    if (stats.isFile() && stats.size < 10 * 1024 * 1024) { // Limit to 10MB files
+        try {
+            // Import the MIME type utilities
+            const { getMimeType, isImageFile } = await import('./mime-types.js');
+            const mimeType = getMimeType(validPath);
+            // Only count lines for non-image, likely text files
+            if (!isImageFile(mimeType)) {
+                const content = await fs.readFile(validPath, 'utf8');
+                const lineCount = content.split('\n').length;
+                info.lineCount = lineCount;
+                info.lastLine = lineCount - 1; // Zero-indexed last line
+                info.appendPosition = lineCount; // Position to append at end
+            }
+        }
+        catch (error) {
+            // If reading fails, just skip the line count
+            // This could happen for binary files or very large files
+        }
+    }
+    return info;
 }
 // This function has been replaced with configManager.getConfig()
 // Use get_config tool to retrieve allowedDirectories

package/dist/tools/schemas.d.ts

@@ -49,12 +49,18 @@ export declare const KillProcessArgsSchema: z.ZodObject<{
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    length: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
+    length: number;
     isUrl: boolean;
+    offset: number;
 }, {
     path: string;
+    length?: number | undefined;
     isUrl?: boolean | undefined;
+    offset?: number | undefined;
 }>;
 export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
     paths: z.ZodArray<z.ZodString, "many">;
@@ -66,12 +72,15 @@ export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
 export declare const WriteFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["rewrite", "append"]>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     content: string;
+    mode: "rewrite" | "append";
 }, {
     path: string;
     content: string;
+    mode?: "rewrite" | "append" | undefined;
 }>;
 export declare const CreateDirectoryArgsSchema: z.ZodObject<{
     path: z.ZodString;

package/dist/tools/schemas.js

@@ -28,6 +28,8 @@ export const KillProcessArgsSchema = z.object({
 export const ReadFileArgsSchema = z.object({
     path: z.string(),
     isUrl: z.boolean().optional().default(false),
+    offset: z.number().optional().default(0),
+    length: z.number().optional().default(1000),
 });
 export const ReadMultipleFilesArgsSchema = z.object({
     paths: z.array(z.string()),
@@ -35,6 +37,7 @@ export const ReadMultipleFilesArgsSchema = z.object({
 export const WriteFileArgsSchema = z.object({
     path: z.string(),
     content: z.string(),
+    mode: z.enum(['rewrite', 'append']).default('rewrite'),
 });
 export const CreateDirectoryArgsSchema = z.object({
     path: z.string(),

package/dist/utils/fuzzySearchLogger.d.ts

@@ -0,0 +1,30 @@
+export interface FuzzySearchLogEntry {
+    timestamp: Date;
+    searchText: string;
+    foundText: string;
+    similarity: number;
+    executionTime: number;
+    exactMatchCount: number;
+    expectedReplacements: number;
+    fuzzyThreshold: number;
+    belowThreshold: boolean;
+    diff: string;
+    searchLength: number;
+    foundLength: number;
+    fileExtension: string;
+    characterCodes: string;
+    uniqueCharacterCount: number;
+    diffLength: number;
+}
+declare class FuzzySearchLogger {
+    private logPath;
+    private initialized;
+    constructor();
+    private ensureLogFile;
+    log(entry: FuzzySearchLogEntry): Promise<void>;
+    getLogPath(): Promise<string>;
+    getRecentLogs(count?: number): Promise<string[]>;
+    clearLog(): Promise<void>;
+}
+export declare const fuzzySearchLogger: FuzzySearchLogger;
+export {};

package/dist/utils/fuzzySearchLogger.js

@@ -0,0 +1,126 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+class FuzzySearchLogger {
+    constructor() {
+        this.initialized = false;
+        // Create log file in a dedicated directory
+        const logDir = path.join(os.homedir(), '.claude-server-commander-logs');
+        this.logPath = path.join(logDir, 'fuzzy-search.log');
+    }
+    async ensureLogFile() {
+        if (this.initialized)
+            return;
+        try {
+            // Create log directory if it doesn't exist
+            const logDir = path.dirname(this.logPath);
+            await fs.mkdir(logDir, { recursive: true });
+            // Check if log file exists, create with headers if not
+            try {
+                await fs.access(this.logPath);
+            }
+            catch {
+                // File doesn't exist, create with headers
+                const headers = [
+                    'timestamp',
+                    'searchText',
+                    'foundText',
+                    'similarity',
+                    'executionTime',
+                    'exactMatchCount',
+                    'expectedReplacements',
+                    'fuzzyThreshold',
+                    'belowThreshold',
+                    'diff',
+                    'searchLength',
+                    'foundLength',
+                    'fileExtension',
+                    'characterCodes',
+                    'uniqueCharacterCount',
+                    'diffLength'
+                ].join('\t');
+                await fs.writeFile(this.logPath, headers + '\n');
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error('Failed to initialize fuzzy search log file:', error);
+            throw error;
+        }
+    }
+    async log(entry) {
+        try {
+            await this.ensureLogFile();
+            // Convert entry to tab-separated string
+            const logLine = [
+                entry.timestamp.toISOString(),
+                entry.searchText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.foundText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.similarity.toString(),
+                entry.executionTime.toString(),
+                entry.exactMatchCount.toString(),
+                entry.expectedReplacements.toString(),
+                entry.fuzzyThreshold.toString(),
+                entry.belowThreshold.toString(),
+                entry.diff.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.searchLength.toString(),
+                entry.foundLength.toString(),
+                entry.fileExtension,
+                entry.characterCodes,
+                entry.uniqueCharacterCount.toString(),
+                entry.diffLength.toString()
+            ].join('\t');
+            await fs.appendFile(this.logPath, logLine + '\n');
+        }
+        catch (error) {
+            console.error('Failed to write to fuzzy search log:', error);
+        }
+    }
+    async getLogPath() {
+        await this.ensureLogFile();
+        return this.logPath;
+    }
+    async getRecentLogs(count = 10) {
+        try {
+            await this.ensureLogFile();
+            const content = await fs.readFile(this.logPath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            // Return last N lines (excluding header)
+            return lines.slice(-count - 1, -1);
+        }
+        catch (error) {
+            console.error('Failed to read fuzzy search logs:', error);
+            return [];
+        }
+    }
+    async clearLog() {
+        try {
+            // Recreate with just headers
+            const headers = [
+                'timestamp',
+                'searchText',
+                'foundText',
+                'similarity',
+                'executionTime',
+                'exactMatchCount',
+                'expectedReplacements',
+                'fuzzyThreshold',
+                'belowThreshold',
+                'diff',
+                'searchLength',
+                'foundLength',
+                'fileExtension',
+                'characterCodes',
+                'uniqueCharacterCount',
+                'diffLength'
+            ].join('\t');
+            await fs.writeFile(this.logPath, headers + '\n');
+            console.log('Fuzzy search log cleared');
+        }
+        catch (error) {
+            console.error('Failed to clear fuzzy search log:', error);
+        }
+    }
+}
+// Singleton instance
+export const fuzzySearchLogger = new FuzzySearchLogger();

package/dist/utils/trackTools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Track tool calls and save them to a log file
+ * @param toolName Name of the tool being called
+ * @param args Arguments passed to the tool (optional)
+ */
+export declare function trackToolCall(toolName: string, args?: unknown): Promise<void>;

package/dist/utils/trackTools.js

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { TOOL_CALL_FILE, TOOL_CALL_FILE_MAX_SIZE } from '../config.js';
+// Ensure the directory for the log file exists
+const logDir = path.dirname(TOOL_CALL_FILE);
+await fs.promises.mkdir(logDir, { recursive: true });
+/**
+ * Track tool calls and save them to a log file
+ * @param toolName Name of the tool being called
+ * @param args Arguments passed to the tool (optional)
+ */
+export async function trackToolCall(toolName, args) {
+    try {
+        // Get current timestamp
+        const timestamp = new Date().toISOString();
+        // Format the log entry
+        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${args ? `\t| Arguments: ${JSON.stringify(args)}` : ''}\n`;
+        // Check if file exists and get its size
+        let fileSize = 0;
+        try {
+            const stats = await fs.promises.stat(TOOL_CALL_FILE);
+            fileSize = stats.size;
+        }
+        catch (err) {
+            // File doesn't exist yet, size remains 0
+        }
+        // If file size is 10MB or larger, rotate the log file
+        if (fileSize >= TOOL_CALL_FILE_MAX_SIZE) {
+            const fileExt = path.extname(TOOL_CALL_FILE);
+            const fileBase = path.basename(TOOL_CALL_FILE, fileExt);
+            const dirName = path.dirname(TOOL_CALL_FILE);
+            // Create a timestamp-based filename for the old log
+            const date = new Date();
+            const rotateTimestamp = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}_${String(date.getHours()).padStart(2, '0')}-${String(date.getMinutes()).padStart(2, '0')}-${String(date.getSeconds()).padStart(2, '0')}`;
+            const newFileName = path.join(dirName, `${fileBase}_${rotateTimestamp}${fileExt}`);
+            // Rename the current file
+            await fs.promises.rename(TOOL_CALL_FILE, newFileName);
+        }
+        // Append to log file (if file was renamed, this will create a new file)
+        await fs.promises.appendFile(TOOL_CALL_FILE, logEntry, 'utf8');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const { capture } = await import('./capture.js');
+        // Send a final telemetry event noting that the user has opted out
+        // This helps us track opt-out rates while respecting the user's choice
+        await capture('server_track_tool_call_error', {
+            error: errorMessage,
+            toolName
+        });
+        // Don't let logging errors affect the main functionality
+        console.error(`Error logging tool call: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.39";
+export declare const VERSION = "0.2.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.39';
+export const VERSION = '0.2.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.39",
+  "version": "0.2.1",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -34,7 +34,11 @@
     "test": "node test/run-all-tests.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
-    "inspector": "npx @modelcontextprotocol/inspector dist/index.js"
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "logs:view": "npm run build && node scripts/view-fuzzy-logs.js",
+    "logs:analyze": "npm run build && node scripts/analyze-fuzzy-logs.js",
+    "logs:clear": "npm run build && node scripts/clear-fuzzy-logs.js",
+    "logs:export": "npm run build && node scripts/export-fuzzy-logs.js"
   },
   "publishConfig": {
     "access": "public"
@@ -69,6 +73,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.17.24",
+    "commander": "^13.1.0",
     "nexe": "^5.0.0-beta.4",
     "nodemon": "^3.0.2",
     "shx": "^0.3.4",