@wonderwhy-er/desktop-commander 0.1.38 → 0.2.0

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,14 +252,30 @@ 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 {
-                const content = await fs.readFile(validPath, "utf-8");
+                // Read the entire file first
+                const buffer = await fs.readFile(validPath);
+                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
+                const startLine = Math.min(offset, totalLines);
+                const endLine = Math.min(startLine + length, totalLines);
+                const selectedLines = lines.slice(startLine, endLine);
+                const truncatedContent = selectedLines.join('\n');
+                // Add an informational message if truncated
+                let content = truncatedContent;
+                if (offset > 0 || endLine < totalLines) {
+                    content = `[Reading ${endLine - startLine} lines from line ${offset} of ${totalLines} total lines]\n\n${truncatedContent}`;
+                }
                 return { content, mimeType, isImage };
             }
             catch (error) {
@@ -278,22 +297,32 @@ 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, "utf-8");
+    // Capture file extension and operation details in telemetry without capturing the file path
+    capture('server_write_file', {
+        fileExtension: fileExtension,
+        mode: mode,
+    });
+    // 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) => {
@@ -339,9 +368,9 @@ export async function searchFiles(rootPath, pattern) {
         }
         catch (error) {
             // Only sanitize for telemetry, not for the returned error
-            capture('server_search_files_error', {
+            capture('server_search_read_dir_error', {
                 errorType: error instanceof Error ? error.name : 'Unknown',
-                errorMessage: 'Error reading directory',
+                error: 'Error reading directory',
                 isReadDirError: true
             });
             return; // Skip this directory on error
@@ -377,7 +406,7 @@ export async function searchFiles(rootPath, pattern) {
         // For telemetry only - sanitize error info
         capture('server_search_files_error', {
             errorType: error instanceof Error ? error.name : 'Unknown',
-            errorMessage: 'Error with root path',
+            error: 'Error with root path',
             isRootPathError: true
         });
         // Re-throw the original error for the caller

package/dist/tools/repl.d.ts

@@ -0,0 +1,21 @@
+import { ServerResult } from '../types.js';
+/**
+ * Create a new REPL session
+ */
+export declare function createREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * Execute code in a REPL session
+ */
+export declare function executeREPLCode(args: unknown): Promise<ServerResult>;
+/**
+ * Terminate a REPL session
+ */
+export declare function terminateREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * List all active REPL sessions
+ */
+export declare function listREPLSessions(args: unknown): Promise<ServerResult>;
+/**
+ * Get information about a specific REPL session
+ */
+export declare function getREPLSessionInfo(args: unknown): Promise<ServerResult>;

package/dist/tools/repl.js

@@ -0,0 +1,217 @@
+import { replManager } from '../repl-manager.js';
+import { capture } from '../utils/capture.js';
+import { CreateREPLSessionArgsSchema, ExecuteREPLCodeArgsSchema, TerminateREPLSessionArgsSchema, ListREPLSessionsArgsSchema, GetREPLSessionInfoArgsSchema } from './schemas.js';
+/**
+ * Create a new REPL session
+ */
+export async function createREPLSession(args) {
+    const parsed = CreateREPLSessionArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_create_repl_session_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for create_repl_session: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const pid = await replManager.createSession(parsed.data.language, parsed.data.timeout);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully created ${parsed.data.language} REPL session with PID ${pid}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_create_repl_session_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error creating REPL session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Execute code in a REPL session
+ */
+export async function executeREPLCode(args) {
+    const parsed = ExecuteREPLCodeArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_execute_repl_code_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for execute_repl_code: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await replManager.executeCode(parsed.data.pid, parsed.data.code, {
+            timeout: parsed.data.timeout,
+            waitForPrompt: parsed.data.waitForPrompt,
+            ignoreErrors: parsed.data.ignoreErrors,
+            multiline: parsed.data.multiline
+        });
+        if (!result.success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: result.error
+                            ? `Error executing code: ${result.error}`
+                            : `Failed to execute code in REPL session ${parsed.data.pid}` +
+                                (result.timeout ? ` (timed out)` : '') +
+                                (result.output ? `\nOutput received: ${result.output}` : '')
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Code executed in REPL session ${parsed.data.pid}` +
+                        (result.timeout ? ` (timed out, partial output below)` : '') +
+                        `\n\nOutput:\n${result.output || '(No output)'}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_execute_repl_code_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error executing REPL code: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Terminate a REPL session
+ */
+export async function terminateREPLSession(args) {
+    const parsed = TerminateREPLSessionArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_terminate_repl_session_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for terminate_repl_session: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const success = await replManager.terminateSession(parsed.data.pid);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Failed to terminate REPL session ${parsed.data.pid}. The session may have already ended.` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully terminated REPL session ${parsed.data.pid}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_terminate_repl_session_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error terminating REPL session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * List all active REPL sessions
+ */
+export async function listREPLSessions(args) {
+    const parsed = ListREPLSessionsArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_list_repl_sessions_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for list_repl_sessions: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const sessions = replManager.listSessions();
+        if (sessions.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No active REPL sessions found`
+                    }],
+            };
+        }
+        const sessionsText = sessions.map(s => `PID: ${s.pid}, Language: ${s.language}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Active REPL sessions:\n${sessionsText}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_list_repl_sessions_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error listing REPL sessions: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get information about a specific REPL session
+ */
+export async function getREPLSessionInfo(args) {
+    const parsed = GetREPLSessionInfoArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_get_repl_session_info_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for get_repl_session_info: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const info = replManager.getSessionInfo(parsed.data.pid);
+        if (!info) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No active REPL session found with PID ${parsed.data.pid}`
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `REPL Session ${parsed.data.pid}:\nLanguage: ${info.language}\nRuntime: ${Math.round(info.runtime / 1000)}s`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_get_repl_session_info_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error getting REPL session info: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

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/tools/send-input.d.ts

@@ -0,0 +1,2 @@
+import { ServerResult } from '../types.js';
+export declare function sendInput(args: unknown): Promise<ServerResult>;

package/dist/tools/send-input.js

@@ -0,0 +1,45 @@
+import { terminalManager } from '../terminal-manager.js';
+import { SendInputArgsSchema } from './schemas.js';
+import { capture } from "../utils/capture.js";
+export async function sendInput(args) {
+    const parsed = SendInputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_send_input_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for send_input: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        capture('server_send_input', {
+            pid: parsed.data.pid,
+            inputLength: parsed.data.input.length
+        });
+        // Try to send input to the process
+        const success = terminalManager.sendInputToProcess(parsed.data.pid, parsed.data.input);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to send input to process ${parsed.data.pid}. The process may have exited or doesn't accept input.` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully sent input to process ${parsed.data.pid}. Use read_output to get the process response.`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_send_input_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error sending input: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

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/lineEndingHandler.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Line ending types
+ */
+export type LineEndingStyle = '\r\n' | '\n' | '\r';
+/**
+ * Detect the line ending style used in a file - Optimized version
+ * This algorithm uses early termination for maximum performance
+ */
+export declare function detectLineEnding(content: string): LineEndingStyle;
+/**
+ * Normalize line endings to match the target style
+ */
+export declare function normalizeLineEndings(text: string, targetLineEnding: LineEndingStyle): string;
+/**
+ * Analyze line ending usage in content
+ */
+export declare function analyzeLineEndings(content: string): {
+    style: LineEndingStyle;
+    count: number;
+    hasMixed: boolean;
+};