@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

package/README.md

@@ -38,6 +38,10 @@ Execute long-running terminal commands on your computer and manage processes thr
 
 ## Features
 
+- **Enhanced terminal commands with interactive process control**
+- **Execute code in memory (Python, Node.js, R) without saving files**
+- **Instant data analysis - just ask to analyze CSV/JSON files**
+- **Interact with running processes (SSH, databases, development servers)**
 - Execute terminal commands with output streaming
 - Command timeout and background execution support
 - Process management (list and kill processes)
@@ -52,6 +56,7 @@ Execute long-running terminal commands on your computer and manage processes thr
   - Move files/directories
   - Search files
   - Get file metadata
+  - **Negative offset file reading**: Read from end of files using negative offset values (like Unix tail)
 - Code editing capabilities:
   - Surgical text replacements for small changes
   - Full file rewrites for major changes
@@ -181,13 +186,14 @@ The server provides a comprehensive set of tools organized into several categori
 |----------|------|-------------|
 | **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled) |
 | | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories)<br>• `fileReadLineLimit`: Maximum lines to read at once (default: 1000)<br>• `fileWriteLineLimit`: Maximum lines to write at once (default: 50)<br>• `telemetryEnabled`: Enable/disable telemetry (boolean) |
-| **Terminal** | `execute_command` | Execute a terminal command with configurable timeout and shell selection |
-| | `read_output` | Read new output from a running terminal session |
+| **Terminal** | `start_process` | Start programs with smart detection of when they're ready for input |
+| | `interact_with_process` | Send commands to running programs and get responses |
+| | `read_process_output` | Read output from running processes |
 | | `force_terminate` | Force terminate a running terminal session |
 | | `list_sessions` | List all active terminal sessions |
 | | `list_processes` | List all running processes with detailed information |
 | | `kill_process` | Terminate a running process by PID |
-| **Filesystem** | `read_file` | Read contents from local filesystem or URLs with line-based pagination (supports offset and length parameters) |
+| **Filesystem** | `read_file` | Read contents from local filesystem or URLs with line-based pagination (supports positive/negative offset and length parameters) |
 | | `read_multiple_files` | Read multiple files simultaneously |
 | | `write_file` | Write file contents with options for rewrite or append mode (uses configurable line limits) |
 | | `create_directory` | Create a new directory or ensure it exists |
@@ -198,6 +204,23 @@ The server provides a comprehensive set of tools organized into several categori
 | | `get_file_info` | Retrieve detailed metadata about a file or directory |
 | **Text Editing** | `edit_block` | Apply targeted text replacements with enhanced prompting for smaller edits (includes character-level diff feedback) |
 
+### Quick Examples
+
+**Data Analysis:**
+```
+"Analyze sales.csv and show top customers" → Claude runs Python code in memory
+```
+
+**Remote Access:**
+```
+"SSH to my server and check disk space" → Claude maintains SSH session
+```
+
+**Development:**
+```
+"Start Node.js and test this API" → Claude runs interactive Node session
+```
+
 ### Tool Usage Examples
 
 Search/Replace Block Format:
@@ -614,4 +637,4 @@ For complete details about data collection, please see our [Privacy Policy](PRIV
 
 ## License
 
-MIT
+MIT

package/dist/config-manager.d.ts

@@ -5,8 +5,14 @@ export interface ServerConfig {
     telemetryEnabled?: boolean;
     fileWriteLineLimit?: number;
     fileReadLineLimit?: number;
+    clientId?: string;
+    currentClient?: ClientInfo;
     [key: string]: any;
 }
+export interface ClientInfo {
+    name: string;
+    version: string;
+}
 /**
  * Singleton config manager for the server
  */
@@ -51,6 +57,10 @@ declare class ConfigManager {
      * Reset configuration to defaults
      */
     resetConfig(): Promise<ServerConfig>;
+    /**
+     * Get current client information for analytics
+     */
+    getCurrentClientInfo(): ClientInfo | null;
 }
 export declare const configManager: ConfigManager;
 export {};

package/dist/config-manager.js

@@ -101,7 +101,7 @@ class ConfigManager {
                 "cipher", // Encrypt/decrypt files or wipe data
                 "takeown" // Take ownership of files
             ],
-            defaultShell: os.platform() === 'win32' ? 'powershell.exe' : 'bash',
+            defaultShell: os.platform() === 'win32' ? 'powershell.exe' : '/bin/sh',
             allowedDirectories: [],
             telemetryEnabled: true, // Default to opt-out approach (telemetry on by default)
             fileWriteLineLimit: 50, // Default line limit for file write operations (changed from 100)
@@ -176,6 +176,12 @@ class ConfigManager {
         await this.saveConfig();
         return { ...this.config };
     }
+    /**
+     * Get current client information for analytics
+     */
+    getCurrentClientInfo() {
+        return this.config.currentClient || null;
+    }
 }
 // Export singleton instance
 export const configManager = new ConfigManager();

package/dist/handlers/edit-search-handlers.js

@@ -14,6 +14,8 @@ export { handleEditBlock };
 export async function handleSearchCode(args) {
     const parsed = SearchCodeArgsSchema.parse(args);
     const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
+    // Limit maxResults to prevent overwhelming responses
+    const safeMaxResults = parsed.maxResults ? Math.min(parsed.maxResults, 5000) : 2000; // Default to 2000 instead of 1000
     // Apply timeout at the handler level
     const searchOperation = async () => {
         return await searchTextInFiles({
@@ -21,7 +23,7 @@ export async function handleSearchCode(args) {
             pattern: parsed.pattern,
             filePattern: parsed.filePattern,
             ignoreCase: parsed.ignoreCase,
-            maxResults: parsed.maxResults,
+            maxResults: safeMaxResults,
             includeHidden: parsed.includeHidden,
             contextLines: parsed.contextLines,
             // Don't pass timeoutMs down to the implementation
@@ -53,16 +55,33 @@ export async function handleSearchCode(args) {
             content: [{ type: "text", text: "No matches found" }],
         };
     }
-    // Format the results in a VS Code-like format
+    // Format the results in a VS Code-like format with early truncation
     let currentFile = "";
     let formattedResults = "";
-    results.forEach(result => {
+    const MAX_RESPONSE_SIZE = 900000; // 900KB limit - well below the 1MB API limit
+    let resultsProcessed = 0;
+    let totalResults = results.length;
+    for (const result of results) {
+        // Check if adding this result would exceed our limit
+        const newFileHeader = result.file !== currentFile ? `\n${result.file}:\n` : '';
+        const newLine = `  ${result.line}: ${result.match}\n`;
+        const potentialAddition = newFileHeader + newLine;
+        // If adding this would exceed the limit, truncate here
+        if (formattedResults.length + potentialAddition.length > MAX_RESPONSE_SIZE) {
+            const remainingResults = totalResults - resultsProcessed;
+            const avgResultLength = formattedResults.length / Math.max(resultsProcessed, 1);
+            const estimatedRemainingChars = remainingResults * avgResultLength;
+            const truncationMessage = `\n\n[Results truncated - ${remainingResults} more results available (approximately ${Math.round(estimatedRemainingChars).toLocaleString()} more characters). Try refining your search pattern or using a more specific file pattern to get fewer results.]`;
+            formattedResults += truncationMessage;
+            break;
+        }
         if (result.file !== currentFile) {
-            formattedResults += `\n${result.file}:\n`;
+            formattedResults += newFileHeader;
             currentFile = result.file;
         }
-        formattedResults += `  ${result.line}: ${result.match}\n`;
-    });
+        formattedResults += newLine;
+        resultsProcessed++;
+    }
     return {
         content: [{ type: "text", text: formattedResults.trim() }],
     };

package/dist/handlers/filesystem-handlers.js

@@ -125,11 +125,9 @@ export async function handleWriteFile(args) {
         const lineCount = lines.length;
         let errorMessage = "";
         if (lineCount > MAX_LINES) {
-            errorMessage = `File was written with warning: Line count limit exceeded: ${lineCount} lines (maximum: ${MAX_LINES}).
+            errorMessage = `✅ File written successfully! (${lineCount} lines)
             
-SOLUTION: Split your content into smaller chunks:
-1. First chunk: write_file(path, firstChunk, {mode: 'rewrite'})
-2. Additional chunks: write_file(path, nextChunk, {mode: 'append'})`;
+💡 Performance tip: For optimal speed, consider chunking files into ≤30 line pieces in future operations.`;
         }
         // Pass the mode parameter to writeFile
         await writeFile(parsed.path, parsed.content, parsed.mode);

package/dist/handlers/terminal-handlers.d.ts

@@ -1,12 +1,16 @@
 import { ServerResult } from '../types.js';
 /**
- * Handle execute_command command
+ * Handle start_process command (improved execute_command)
  */
-export declare function handleExecuteCommand(args: unknown): Promise<ServerResult>;
+export declare function handleStartProcess(args: unknown): Promise<ServerResult>;
 /**
- * Handle read_output command
+ * Handle read_process_output command (improved read_output)
  */
-export declare function handleReadOutput(args: unknown): Promise<ServerResult>;
+export declare function handleReadProcessOutput(args: unknown): Promise<ServerResult>;
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export declare function handleInteractWithProcess(args: unknown): Promise<ServerResult>;
 /**
  * Handle force_terminate command
  */

package/dist/handlers/terminal-handlers.js

@@ -1,18 +1,24 @@
-import { executeCommand, readOutput, forceTerminate, listSessions } from '../tools/execute.js';
-import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
+import { startProcess, readProcessOutput, interactWithProcess, forceTerminate, listSessions } from '../tools/improved-process-tools.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
 /**
- * Handle execute_command command
+ * Handle start_process command (improved execute_command)
  */
-export async function handleExecuteCommand(args) {
-    const parsed = ExecuteCommandArgsSchema.parse(args);
-    return executeCommand(parsed);
+export async function handleStartProcess(args) {
+    const parsed = StartProcessArgsSchema.parse(args);
+    return startProcess(parsed);
 }
 /**
- * Handle read_output command
+ * Handle read_process_output command (improved read_output)
  */
-export async function handleReadOutput(args) {
-    const parsed = ReadOutputArgsSchema.parse(args);
-    return readOutput(parsed);
+export async function handleReadProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.parse(args);
+    return readProcessOutput(parsed);
+}
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export async function handleInteractWithProcess(args) {
+    return interactWithProcess(args);
 }
 /**
  * Handle force_terminate command

package/dist/index-dxt.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index-dxt.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// Add immediate logging before any imports
+console.error("[DXT] === ENTRY POINT START ===");
+console.error(`[DXT] Node version: ${process.version}`);
+console.error(`[DXT] Platform: ${process.platform}`);
+console.error(`[DXT] Working directory: ${process.cwd()}`);
+console.error(`[DXT] __dirname: ${__dirname}`);
+console.error(`[DXT] Args: ${JSON.stringify(process.argv)}`);
+// Add error handlers immediately
+process.on('uncaughtException', (error) => {
+    console.error(`[DXT] UNCAUGHT EXCEPTION: ${error.message}`);
+    console.error(`[DXT] Stack: ${error.stack}`);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error(`[DXT] UNHANDLED REJECTION: ${String(reason)}`);
+});
+process.on('exit', (code) => {
+    console.error(`[DXT] PROCESS EXITING with code: ${code}`);
+});
+console.error("[DXT] About to import modules...");
+// Simplified entry point for DXT that avoids configuration loading issues
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+console.error("[DXT] FilteredStdioServerTransport imported");
+import { server } from './server.js';
+console.error("[DXT] Server imported");
+async function runDXTServer() {
+    try {
+        console.error("[DXT] === runDXTServer() START ===");
+        console.error("=== DXT DEBUG START ===");
+        console.error(`Node version: ${process.version}`);
+        console.error(`Platform: ${process.platform}`);
+        console.error(`Working directory: ${process.cwd()}`);
+        console.error(`__dirname: ${__dirname}`);
+        console.error(`Args: ${JSON.stringify(process.argv)}`);
+        console.error("=== DXT DEBUG END ===");
+        console.error("[DXT] About to create transport...");
+        // Create transport
+        const transport = new FilteredStdioServerTransport();
+        console.error("[DXT] Transport created successfully");
+        // Send structured debug info
+        transport.sendLog("info", "DXT Server Starting", {
+            nodeVersion: process.version,
+            platform: process.platform,
+            cwd: process.cwd(),
+            dirname: __dirname,
+            argv: process.argv
+        });
+        console.error("[DXT] Debug info sent via transport");
+        // Connect server
+        console.error("[DXT] About to connect server...");
+        console.error("Connecting MCP server...");
+        await server.connect(transport);
+        console.error("[DXT] Server connected successfully!");
+        console.error("MCP server connected successfully");
+        transport.sendLog("info", "MCP server connected successfully in DXT mode");
+        console.error("[DXT] === runDXTServer() END ===");
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        console.error(`[DXT] FATAL ERROR in runDXTServer: ${errorMessage}`);
+        if (errorStack) {
+            console.error(`[DXT] Stack: ${errorStack}`);
+        }
+        process.exit(1);
+    }
+}
+console.error("[DXT] About to call runDXTServer...");
+// Run the server
+runDXTServer().catch((error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[DXT] Failed to start in catch block: ${errorMessage}`);
+    console.error(`[DXT] Failed to start: ${errorMessage}`);
+    process.exit(1);
+});
+console.error("[DXT] === ENTRY POINT END ===");

package/dist/index-with-startup-detection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Example integration of startup detection in your server.ts file
+ * This shows how to add startup detection to your existing server
+ */
+export {};

package/dist/index-with-startup-detection.js

@@ -0,0 +1,180 @@
+/**
+ * Example integration of startup detection in your server.ts file
+ * This shows how to add startup detection to your existing server
+ */
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+import { server } from './server.js';
+import { configManager } from './config-manager.js';
+import { getStartupInfo, getStartupMethod, isProduction, isDevelopment, isDocker, isCi } from './utils/startup-detector.js';
+import { capture } from './utils/capture.js';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { platform } from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isWindows = platform() === 'win32';
+function createFileURL(filePath) {
+    if (isWindows) {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        if (normalizedPath.startsWith('/')) {
+            return new URL(`file://${normalizedPath}`);
+        }
+        else {
+            return new URL(`file:///${normalizedPath}`);
+        }
+    }
+    else {
+        return pathToFileURL(filePath);
+    }
+}
+async function runSetup() {
+    try {
+        const setupScriptPath = join(__dirname, 'setup-claude-server.js');
+        const setupScriptUrl = createFileURL(setupScriptPath);
+        const { default: setupModule } = await import(setupScriptUrl.href);
+        if (typeof setupModule === 'function') {
+            await setupModule();
+        }
+    }
+    catch (error) {
+        console.error('Error running setup:', error);
+        process.exit(1);
+    }
+}
+async function runServer() {
+    try {
+        // Check if first argument is "setup"
+        if (process.argv[2] === 'setup') {
+            await runSetup();
+            return;
+        }
+        // ============ NEW: Startup Detection Integration ============
+        const startupInfo = getStartupInfo();
+        const startupMethod = getStartupMethod();
+        // Log startup information
+        console.error(`🚀 Desktop Commander starting via: ${startupMethod}`);
+        console.error(`📍 Environment: ${startupInfo.environment}`);
+        console.error(`🔍 Detection confidence: ${startupInfo.confidence}%`);
+        if (startupInfo.details.evidence.length > 0) {
+            console.error(`📝 Evidence: ${startupInfo.details.evidence.join(', ')}`);
+        }
+        // Conditional behavior based on startup method
+        if (isProduction()) {
+            console.error('🏭 Production mode: Enhanced error handling enabled');
+            // Enable production-specific features
+            process.on('uncaughtException', (error) => {
+                console.error('[PRODUCTION] Uncaught exception:', error);
+                // More robust error handling in production
+                process.exit(1);
+            });
+        }
+        else if (isDevelopment()) {
+            console.error('🛠️  Development mode: Debug features enabled');
+            // Enable development-specific features
+        }
+        if (isDocker()) {
+            console.error('🐳 Docker environment detected');
+            // Docker-specific configuration
+        }
+        if (isCi()) {
+            console.error('🤖 CI/CD environment detected');
+            // CI-specific behavior (minimal logging, etc.)
+        }
+        // Log startup analytics
+        capture('desktop_commander_startup', {
+            startup_method: startupInfo.method,
+            environment: startupInfo.environment,
+            confidence: startupInfo.confidence,
+            npm_script: startupInfo.details.npmScript || null,
+            ci_platform: startupInfo.details.ciPlatform || null,
+            docker_container: startupInfo.details.dockerContainer || false
+        });
+        // Adjust logging verbosity based on environment
+        const logLevel = isProduction() ? 'error' :
+            isDevelopment() ? 'debug' :
+                isCi() ? 'warn' : 'info';
+        console.error(`📊 Log level set to: ${logLevel}`);
+        // ========================================================
+        const transport = new FilteredStdioServerTransport();
+        // Enhanced error handling with startup context
+        process.on('uncaughtException', async (error) => {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                process.stderr.write(`[desktop-commander] JSON parsing error: ${errorMessage}\n`);
+                return;
+            }
+            // Include startup context in error capture
+            capture('run_server_uncaught_exception', {
+                error: errorMessage,
+                startup_method: startupInfo.method,
+                environment: startupInfo.environment
+            });
+            process.stderr.write(`[desktop-commander] Uncaught exception: ${errorMessage}\n`);
+            process.exit(1);
+        });
+        process.on('unhandledRejection', async (reason) => {
+            const errorMessage = reason instanceof Error ? reason.message : String(reason);
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                process.stderr.write(`[desktop-commander] JSON parsing rejection: ${errorMessage}\n`);
+                return;
+            }
+            capture('run_server_unhandled_rejection', {
+                error: errorMessage,
+                startup_method: startupInfo.method,
+                environment: startupInfo.environment
+            });
+            process.stderr.write(`[desktop-commander] Unhandled rejection: ${errorMessage}\n`);
+            process.exit(1);
+        });
+        capture('run_server_start', {
+            startup_method: startupInfo.method,
+            environment: startupInfo.environment
+        });
+        try {
+            console.error("Loading configuration...");
+            await configManager.loadConfig();
+            console.error("Configuration loaded successfully");
+        }
+        catch (configError) {
+            console.error(`Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            console.error(configError instanceof Error && configError.stack ? configError.stack : 'No stack trace available');
+            console.error("Continuing with in-memory configuration only");
+        }
+        console.error("Connecting server...");
+        await server.connect(transport);
+        console.error("✅ Server connected successfully");
+        console.error(`🎯 Running in ${startupInfo.environment} environment via ${startupMethod}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`FATAL ERROR: ${errorMessage}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+        process.stderr.write(JSON.stringify({
+            type: 'error',
+            timestamp: new Date().toISOString(),
+            message: `Failed to start server: ${errorMessage}`,
+            startup_method: getStartupInfo().method
+        }) + '\n');
+        capture('run_server_failed_start_error', {
+            error: errorMessage,
+            startup_method: getStartupInfo().method
+        });
+        process.exit(1);
+    }
+}
+runServer().catch(async (error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`RUNTIME ERROR: ${errorMessage}`);
+    console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+    process.stderr.write(JSON.stringify({
+        type: 'error',
+        timestamp: new Date().toISOString(),
+        message: `Fatal error running server: ${errorMessage}`,
+        startup_method: getStartupInfo().method
+    }) + '\n');
+    capture('run_server_fatal_error', {
+        error: errorMessage,
+        startup_method: getStartupInfo().method
+    });
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -22,3 +22,8 @@ export declare const server: Server<{
         [x: string]: unknown;
     } | undefined;
 }>;
+declare let currentClient: {
+    name: string;
+    version: string;
+};
+export { currentClient };