@wonderwhy-er/desktop-commander 0.1.33 → 0.1.35

package/dist/server.js

@@ -1,9 +1,11 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, BlockCommandArgsSchema, UnblockCommandArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, SearchCodeArgsSchema, } from './tools/schemas.js';
+import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, } from './tools/schemas.js';
+import { getConfig, setConfigValue } from './tools/config.js';
 import { VERSION } from './version.js';
 import { capture } from "./utils.js";
+console.error("Loading server.ts");
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -28,210 +30,188 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
         prompts: [],
     };
 });
+console.error("Setting up request handlers...");
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            // Terminal tools
-            {
-                name: "execute_command",
-                description: "Execute a terminal command with timeout. Command will continue running in background if it doesn't complete within timeout.",
-                inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
-            },
-            {
-                name: "read_output",
-                description: "Read new output from a running terminal session.",
-                inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
-            },
-            {
-                name: "force_terminate",
-                description: "Force terminate a running terminal session.",
-                inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
-            },
-            {
-                name: "list_sessions",
-                description: "List all active terminal sessions.",
-                inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
-            },
-            {
-                name: "list_processes",
-                description: "List all running processes. Returns process information including PID, " +
-                    "command name, CPU usage, and memory usage.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            {
-                name: "kill_process",
-                description: "Terminate a running process by PID. Use with caution as this will " +
-                    "forcefully terminate the specified process.",
-                inputSchema: zodToJsonSchema(KillProcessArgsSchema),
-            },
-            {
-                name: "block_command",
-                description: "Add a command to the blacklist. Once blocked, the command cannot be executed until unblocked.",
-                inputSchema: zodToJsonSchema(BlockCommandArgsSchema),
-            },
-            {
-                name: "unblock_command",
-                description: "Remove a command from the blacklist. Once unblocked, the command can be executed normally.",
-                inputSchema: zodToJsonSchema(UnblockCommandArgsSchema),
-            },
-            {
-                name: "list_blocked_commands",
-                description: "List all currently blocked commands.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            // Filesystem tools
-            {
-                name: "read_file",
-                description: "Read the complete contents of a file from the file system or a URL. " +
-                    "When reading from the file system, only works within allowed directories. " +
-                    "Can fetch content from URLs when isUrl parameter is set to true. " +
-                    "Handles text files normally and image files are returned as viewable images. " +
-                    "Recognized image types: PNG, JPEG, GIF, WebP.",
-                inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-            },
-            {
-                name: "read_multiple_files",
-                description: "Read the contents of multiple files simultaneously. " +
-                    "Each file's content is returned with its path as a reference. " +
-                    "Handles text files normally and renders images as viewable content. " +
-                    "Recognized image types: PNG, JPEG, GIF, WebP. " +
-                    "Failed reads for individual files won't stop the entire operation. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
-            },
-            {
-                name: "write_file",
-                description: "Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. " +
-                    "Use with caution as it will overwrite existing files. Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-            },
-            {
-                name: "create_directory",
-                description: "Create a new directory or ensure a directory exists. Can create multiple " +
-                    "nested directories in one operation. Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
-            },
-            {
-                name: "list_directory",
-                description: "Get a detailed listing of all files and directories in a specified path. " +
-                    "Results distinguish between files and directories with [FILE] and [DIR] prefixes. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-            },
-            {
-                name: "move_file",
-                description: "Move or rename files and directories. Can move files between directories " +
-                    "and rename them in a single operation. Both source and destination must be " +
-                    "within allowed directories.",
-                inputSchema: zodToJsonSchema(MoveFileArgsSchema),
-            },
-            {
-                name: "search_files",
-                description: "Finds files by name using a case-insensitive substring matching. " +
-                    "Searches through all subdirectories from the starting path. " +
-                    "Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. " +
-                    "Only searches within allowed directories.",
-                inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
-            },
-            {
-                name: "search_code",
-                description: "Search for text/code patterns within file contents using ripgrep. " +
-                    "Fast and powerful search similar to VS Code search functionality. " +
-                    "Supports regular expressions, file pattern filtering, and context lines. " +
-                    "Has a default timeout of 30 seconds which can be customized. " +
-                    "Only searches within allowed directories.",
-                inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
-            },
-            {
-                name: "get_file_info",
-                description: "Retrieve detailed metadata about a file or directory including size, " +
-                    "creation time, last modified time, permissions, and type. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
-            },
-            {
-                name: "list_allowed_directories",
-                description: "Returns the list of directories that this server is allowed to access.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            {
-                name: "edit_block",
-                description: "Apply surgical text replacements to files. Best for small changes (<20% of file size). " +
-                    "Call repeatedly to change multiple blocks. Will verify changes after application. " +
-                    "Format:\nfilepath\n<<<<<<< SEARCH\ncontent to find\n=======\nnew content\n>>>>>>> REPLACE",
-                inputSchema: zodToJsonSchema(EditBlockArgsSchema),
-            },
-        ],
-    };
+    try {
+        console.error("Generating tools list...");
+        return {
+            tools: [
+                // Configuration tools
+                {
+                    name: "get_config",
+                    description: "Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access).",
+                    inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                },
+                {
+                    name: "set_config_value",
+                    description: "Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system.",
+                    inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
+                },
+                // Terminal tools
+                {
+                    name: "execute_command",
+                    description: "Execute a terminal command with timeout. Command will continue running in background if it doesn't complete within timeout.",
+                    inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
+                },
+                {
+                    name: "read_output",
+                    description: "Read new output from a running terminal session.",
+                    inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
+                },
+                {
+                    name: "force_terminate",
+                    description: "Force terminate a running terminal session.",
+                    inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
+                },
+                {
+                    name: "list_sessions",
+                    description: "List all active terminal sessions.",
+                    inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
+                },
+                {
+                    name: "list_processes",
+                    description: "List all running processes. Returns process information including PID, command name, CPU usage, and memory usage.",
+                    inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
+                },
+                {
+                    name: "kill_process",
+                    description: "Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process.",
+                    inputSchema: zodToJsonSchema(KillProcessArgsSchema),
+                },
+                // Filesystem tools
+                {
+                    name: "read_file",
+                    description: "Read the complete contents of a file from the file system or a URL. When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true. Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP.",
+                    inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                },
+                {
+                    name: "read_multiple_files",
+                    description: "Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories.",
+                    inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
+                },
+                {
+                    name: "write_file",
+                    description: "Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. Use with caution as it will overwrite existing files. Only works within allowed directories.",
+                    inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                },
+                {
+                    name: "create_directory",
+                    description: "Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories.",
+                    inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
+                },
+                {
+                    name: "list_directory",
+                    description: "Get a detailed listing of all files and directories in a specified path. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories.",
+                    inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                },
+                {
+                    name: "move_file",
+                    description: "Move or rename files and directories. Can move files between directories and rename them in a single operation. Both source and destination must be within allowed directories.",
+                    inputSchema: zodToJsonSchema(MoveFileArgsSchema),
+                },
+                {
+                    name: "search_files",
+                    description: "Finds files by name using a case-insensitive substring matching. Searches through all subdirectories from the starting path. Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. Only searches within allowed directories.",
+                    inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
+                },
+                {
+                    name: "search_code",
+                    description: "Search for text/code patterns within file contents using ripgrep. Fast and powerful search similar to VS Code search functionality. Supports regular expressions, file pattern filtering, and context lines. Has a default timeout of 30 seconds which can be customized. Only searches within allowed directories.",
+                    inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
+                },
+                {
+                    name: "get_file_info",
+                    description: "Retrieve detailed metadata about a file or directory including size, creation time, last modified time, permissions, and type. Only works within allowed directories.",
+                    inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
+                },
+                // Note: list_allowed_directories removed - use get_config to check allowedDirectories
+                // Text editing tools
+                {
+                    name: "edit_block",
+                    description: "Apply surgical text replacements to files. Best for small changes (<20% of file size). Call repeatedly to change multiple blocks. Will verify changes after application. Format:\nfilepath\n<<<<<<< SEARCH\ncontent to find\n=======\nnew content\n>>>>>>> REPLACE",
+                    inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error in list_tools request handler:", error);
+        throw error;
+    }
 });
 import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
-        capture('server_call_tool');
-        // Add a single dynamic capture for the specific tool
-        capture('server_' + name);
+        capture('server_call_tool', {
+            name
+        });
         // Using a more structured approach with dedicated handlers
         switch (name) {
+            // Config tools
+            case "get_config":
+                try {
+                    return await getConfig();
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_config handler: ${error}` });
+                    return {
+                        content: [{ type: "text", text: `Error: Failed to get configuration` }],
+                        isError: true,
+                    };
+                }
+            case "set_config_value":
+                try {
+                    return await setConfigValue(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in set_config_value handler: ${error}` });
+                    return {
+                        content: [{ type: "text", text: `Error: Failed to set configuration value` }],
+                        isError: true,
+                    };
+                }
             // Terminal tools
             case "execute_command":
-                return handlers.handleExecuteCommand(args);
+                return await handlers.handleExecuteCommand(args);
             case "read_output":
-                return handlers.handleReadOutput(args);
+                return await handlers.handleReadOutput(args);
             case "force_terminate":
-                return handlers.handleForceTerminate(args);
+                return await handlers.handleForceTerminate(args);
             case "list_sessions":
-                return handlers.handleListSessions();
+                return await handlers.handleListSessions();
             // Process tools
             case "list_processes":
-                return handlers.handleListProcesses();
+                return await handlers.handleListProcesses();
             case "kill_process":
-                return handlers.handleKillProcess(args);
-            // Command management tools
-            case "block_command":
-                return handlers.handleBlockCommand(args);
-            case "unblock_command":
-                return handlers.handleUnblockCommand(args);
-            case "list_blocked_commands":
-                return handlers.handleListBlockedCommands();
+                return await handlers.handleKillProcess(args);
             // Filesystem tools
             case "read_file":
-                return handlers.handleReadFile(args);
+                return await handlers.handleReadFile(args);
             case "read_multiple_files":
-                return handlers.handleReadMultipleFiles(args);
+                return await handlers.handleReadMultipleFiles(args);
             case "write_file":
-                return handlers.handleWriteFile(args);
+                return await handlers.handleWriteFile(args);
             case "create_directory":
-                return handlers.handleCreateDirectory(args);
+                return await handlers.handleCreateDirectory(args);
             case "list_directory":
-                return handlers.handleListDirectory(args);
+                return await handlers.handleListDirectory(args);
             case "move_file":
-                return handlers.handleMoveFile(args);
+                return await handlers.handleMoveFile(args);
             case "search_files":
-                return handlers.handleSearchFiles(args);
+                return await handlers.handleSearchFiles(args);
             case "search_code":
-                return handlers.handleSearchCode(args);
+                return await handlers.handleSearchCode(args);
             case "get_file_info":
-                return handlers.handleGetFileInfo(args);
-            case "list_allowed_directories":
-                return handlers.handleListAllowedDirectories();
+                return await handlers.handleGetFileInfo(args);
             case "edit_block":
-                return handlers.handleEditBlock(args);
+                return await handlers.handleEditBlock(args);
             default:
                 capture('server_unknown_tool', { name });
-                throw new Error(`Unknown tool: ${name}`);
+                return {
+                    content: [{ type: "text", text: `Error: Unknown tool: ${name}` }],
+                    isError: true,
+                };
         }
     }
     catch (error) {

package/dist/setup-claude-server.js

@@ -5,28 +5,25 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { exec } from "node:child_process";
 import { version as nodeVersion } from 'process';
+import * as https from 'https';
 
-// Optional analytics - will gracefully degrade if posthog-node isn't available
-let client = null;
+// Google Analytics configuration
+const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
+const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';   // Replace with your GA4 API Secret
+const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+
+// Optional analytics - will gracefully degrade if dependencies aren't available
 let uniqueUserId = 'unknown';
 
 try {
-    const { PostHog } = await import('posthog-node');
+    // Only dependency is node-machine-id
     const machineIdModule = await import('node-machine-id');
-    
-    client = new PostHog(
-        'phc_BW8KJ0cajzj2v8qfMhvDQ4dtFdgHPzeYcMRvRFGvQdH',
-        { 
-            host: 'https://eu.i.posthog.com',
-            flushAt: 1, // send all every time
-            flushInterval: 0 //send always
-        }
-    );
-    
+  
     // Get a unique user ID
     uniqueUserId = machineIdModule.machineIdSync();
 } catch (error) {
-    //console.error('Analytics module not available - continuing without tracking');
+    // Fall back to a semi-unique identifier if machine-id is not available
+    uniqueUserId = `${platform()}-${process.env.USER || process.env.USERNAME || 'unknown'}-${Date.now()}`;
 }
 
 // Function to get npm version
@@ -127,33 +124,98 @@ async function getTrackingProperties(additionalProps = {}) {
   const version = await getVersion();
   return {
     platform: platform(),
-    nodeVersion: nodeVersion,
-    npmVersion: npmVersionCache,
-    executionContext: context.runMethod,
-    isCI: context.isCI,
+    node_version: nodeVersion,
+    npm_version: npmVersionCache,
+    execution_context: context.runMethod,
+    is_ci: context.isCI,
     shell: context.shell,
-    DCVersion: version,
-    timestamp: new Date().toISOString(),
+    app_version: version,
+    engagement_time_msec: "100",
     ...additionalProps
   };
 }
 
-// Helper function for tracking that handles missing PostHog gracefully
+// Helper function for tracking that handles errors gracefully
 async function trackEvent(eventName, additionalProps = {}) {
-  if (!client) return; // Skip tracking if PostHog client isn't available
+  if (!GA_MEASUREMENT_ID || !GA_API_SECRET) return; // Skip tracking if GA isn't configured
   
   try {
-    client.capture({
-      distinctId: uniqueUserId,
-      event: eventName,
-      properties: await getTrackingProperties(additionalProps)
+    // Get enriched properties
+    const eventProperties = await getTrackingProperties(additionalProps);
+    
+    // Prepare GA4 payload
+    const payload = {
+      client_id: uniqueUserId,
+      non_personalized_ads: false,
+      timestamp_micros: Date.now() * 1000,
+      events: [{
+        name: eventName,
+        params: eventProperties
+      }]
+    };
+    
+    // Send to Google Analytics
+    const postData = JSON.stringify(payload);
+    
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+    
+    return new Promise((resolve) => {
+      const req = https.request(GA_BASE_URL, options, (res) => {
+        // Optional response handling
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        
+        res.on('end', () => {
+          resolve(true);
+        });
+      });
+      
+      req.on('error', (error) => {
+        // Silently fail - we don't want tracking issues to break functionality
+        resolve(false);
+      });
+      
+      // Set timeout to prevent blocking
+      req.setTimeout(3000, () => {
+        req.destroy();
+        resolve(false);
+      });
+      
+      req.write(postData);
+      req.end();
+
+      // read response from request
+      req.on('response', (res) => {
+        // Optional response handling
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        //response status
+        res.on('error', (error) => {
+          resolve(false);
+        });
+        
+        res.on('end', () => {
+          resolve(true);
+        });
+      });
     });
   } catch (error) {
-    // Silently fail if tracking fails - we don't want to break the setup process
-    //console.log(`Note: Event tracking unavailable for ${eventName}`);
+    logToFile(`Error tracking event ${eventName}: ${error}`, true);
+    // Silently fail if tracking fails - we don't want to break the application
+    return false;
   }
 }
-
 // Initial tracking
 trackEvent('npx_setup_start');
 
@@ -258,12 +320,16 @@ async function restartClaude() {
             } else if (platform === "linux") {
                 await execAsync(`claude`)
             }
-        } catch{}
+            logToFile(`Claude has been restarted.`)
+        } catch{
 
-		logToFile(`Claude has been restarted.`)
+        }
+
+		
 	} catch (error) {
         await trackEvent('npx_setup_restart_claude_error', { error: error.message });
-		logToFile(`Failed to restart Claude: ${error}`, true)
+		logToFile(`Failed to restart Claude: ${error}. Please restart it manually.`, true)
+        logToFile(`If Claude Desktop is not installed use this link to download https://claude.ai/download`, true)
 	}
 }
 
@@ -413,26 +479,9 @@ export default async function setup() {
         
         await trackEvent('npx_setup_complete');
         
-        // Safe shutdown
-        if (client) {
-            try {
-                await client.shutdown();
-            } catch (error) {
-                // Ignore shutdown errors
-            }
-        }
     } catch (error) {
         await trackEvent('npx_setup_final_error', { error: error.message });
         logToFile(`Error updating Claude configuration: ${error}`, true);
-        
-        // Safe shutdown
-        if (client) {
-            try {
-                await client.shutdown();
-            } catch (error) {
-                // Ignore shutdown errors
-            }
-        }
         process.exit(1);
     }
 }

package/dist/terminal-manager.d.ts

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

package/dist/terminal-manager.js

@@ -1,16 +1,38 @@
 import { spawn } from 'child_process';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
+import { configManager } from './config-manager.js';
+import { capture } from "./utils.js";
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.completedSessions = new Map();
     }
-    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
-        const process = spawn(command, [], { shell: true });
+    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell) {
+        // Get the shell from config if not specified
+        let shellToUse = shell;
+        if (!shellToUse) {
+            try {
+                const config = await configManager.getConfig();
+                shellToUse = config.shell || true;
+            }
+            catch (error) {
+                // If there's an error getting the config, fall back to default
+                shellToUse = true;
+            }
+        }
+        const spawnOptions = {
+            shell: shellToUse
+        };
+        const process = spawn(command, [], spawnOptions);
         let output = '';
         // Ensure process.pid is defined before proceeding
         if (!process.pid) {
-            throw new Error('Failed to get process ID');
+            // Return a consistent error object instead of throwing
+            return {
+                pid: -1, // Use -1 to indicate an error state
+                output: 'Error: Failed to get process ID. The command could not be executed.',
+                isBlocked: false
+            };
         }
         const session = {
             pid: process.pid,
@@ -96,7 +118,7 @@ export class TerminalManager {
             return true;
         }
         catch (error) {
-            console.error(`Failed to terminate process ${pid}:`, error);
+            capture('server_request_error', { error: error, message: `Failed to terminate process ${pid}:` });
             return false;
         }
     }