@wonderwhy-er/desktop-commander 0.1.32 → 0.1.34

package/dist/error-handlers.d.ts

@@ -0,0 +1,7 @@
+import { ServerResult } from './types.js';
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export declare function createErrorResponse(message: string): ServerResult;

package/dist/error-handlers.js

@@ -0,0 +1,11 @@
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export function createErrorResponse(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}

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

@@ -1,27 +1,13 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle block_command command
  */
-export declare function handleBlockCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: boolean;
-    }[];
-}>;
+export declare function handleBlockCommand(args: unknown): Promise<ServerResult>;
 /**
  * Handle unblock_command command
  */
-export declare function handleUnblockCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: boolean;
-    }[];
-}>;
+export declare function handleUnblockCommand(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_blocked_commands command
  */
-export declare function handleListBlockedCommands(): {
-    content: {
-        type: string;
-        text: string;
-    }[];
-};
+export declare function handleListBlockedCommands(): ServerResult;

package/dist/handlers/command-handlers.js

@@ -6,8 +6,12 @@ import { BlockCommandArgsSchema, UnblockCommandArgsSchema } from '../tools/schem
 export async function handleBlockCommand(args) {
     const parsed = BlockCommandArgsSchema.parse(args);
     const blockResult = await commandManager.blockCommand(parsed.command);
+    // Convert boolean result to appropriate message string
+    const message = blockResult
+        ? `Successfully blocked command: ${parsed.command}`
+        : `Command is already blocked: ${parsed.command}`;
     return {
-        content: [{ type: "text", text: blockResult }],
+        content: [{ type: "text", text: message }],
     };
 }
 /**
@@ -16,8 +20,12 @@ export async function handleBlockCommand(args) {
 export async function handleUnblockCommand(args) {
     const parsed = UnblockCommandArgsSchema.parse(args);
     const unblockResult = await commandManager.unblockCommand(parsed.command);
+    // Convert boolean result to appropriate message string
+    const message = unblockResult
+        ? `Successfully unblocked command: ${parsed.command}`
+        : `Command is not blocked or doesn't exist: ${parsed.command}`;
     return {
-        content: [{ type: "text", text: unblockResult }],
+        content: [{ type: "text", text: message }],
     };
 }
 /**
@@ -25,7 +33,11 @@ export async function handleUnblockCommand(args) {
  */
 export function handleListBlockedCommands() {
     const blockedCommands = commandManager.listBlockedCommands();
+    // Create appropriate message based on whether there are blocked commands
+    const message = blockedCommands.length > 0
+        ? `Blocked commands:\n${blockedCommands.join('\n')}`
+        : "No commands are currently blocked.";
     return {
-        content: [{ type: "text", text: blockedCommands.join('\n') }],
+        content: [{ type: "text", text: message }],
     };
 }

package/dist/handlers/edit-search-handlers.d.ts

@@ -1,18 +1,9 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle edit_block command
  */
-export declare function handleEditBlock(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
 /**
  * Handle search_code command
  */
-export declare function handleSearchCode(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleSearchCode(args: unknown): Promise<ServerResult>;

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

@@ -2,16 +2,23 @@ import { parseEditBlock, performSearchReplace } from '../tools/edit.js';
 import { searchTextInFiles } from '../tools/search.js';
 import { EditBlockArgsSchema, SearchCodeArgsSchema } from '../tools/schemas.js';
 import { withTimeout } from '../utils.js';
+import { createErrorResponse } from '../error-handlers.js';
 /**
  * Handle edit_block command
  */
 export async function handleEditBlock(args) {
-    const parsed = EditBlockArgsSchema.parse(args);
-    const { filePath, searchReplace } = await parseEditBlock(parsed.blockContent);
-    await performSearchReplace(filePath, searchReplace);
-    return {
-        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-    };
+    try {
+        const parsed = EditBlockArgsSchema.parse(args);
+        const { filePath, searchReplace, error } = await parseEditBlock(parsed.blockContent);
+        if (error) {
+            return createErrorResponse(error);
+        }
+        return performSearchReplace(filePath, searchReplace);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle search_code command

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

@@ -1,90 +1,37 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle read_file command
  */
-export declare function handleReadFile(args: unknown): Promise<{
-    content: ({
-        type: string;
-        text: string;
-        data?: undefined;
-        mimeType?: undefined;
-    } | {
-        type: string;
-        data: string;
-        mimeType: string;
-        text?: undefined;
-    })[];
-}>;
+export declare function handleReadFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle read_multiple_files command
  */
-export declare function handleReadMultipleFiles(args: unknown): Promise<{
-    content: {
-        type: string;
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }[];
-}>;
+export declare function handleReadMultipleFiles(args: unknown): Promise<ServerResult>;
 /**
  * Handle write_file command
  */
-export declare function handleWriteFile(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleWriteFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle create_directory command
  */
-export declare function handleCreateDirectory(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleCreateDirectory(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_directory command
  */
-export declare function handleListDirectory(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleListDirectory(args: unknown): Promise<ServerResult>;
 /**
  * Handle move_file command
  */
-export declare function handleMoveFile(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleMoveFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle search_files command
  */
-export declare function handleSearchFiles(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleSearchFiles(args: unknown): Promise<ServerResult>;
 /**
  * Handle get_file_info command
  */
-export declare function handleGetFileInfo(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleGetFileInfo(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_allowed_directories command
  */
-export declare function handleListAllowedDirectories(): {
-    content: {
-        type: string;
-        text: string;
-    }[];
-};
+export declare function handleListAllowedDirectories(): ServerResult;

package/dist/handlers/filesystem-handlers.js

@@ -1,6 +1,19 @@
 import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo, listAllowedDirectories } from '../tools/filesystem.js';
 import { withTimeout } from '../utils.js';
+import { createErrorResponse } from '../error-handlers.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema } from '../tools/schemas.js';
+/**
+ * Helper function to check if path contains an error
+ */
+function isErrorPath(path) {
+    return path.startsWith('__ERROR__:');
+}
+/**
+ * Extract error message from error path
+ */
+function getErrorFromPath(path) {
+    return path.substring('__ERROR__:'.length).trim();
+}
 /**
  * Handle read_file command
  */
@@ -86,84 +99,120 @@ export async function handleReadMultipleFiles(args) {
  * Handle write_file command
  */
 export async function handleWriteFile(args) {
-    const parsed = WriteFileArgsSchema.parse(args);
-    await writeFile(parsed.path, parsed.content);
-    return {
-        content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
-    };
+    try {
+        const parsed = WriteFileArgsSchema.parse(args);
+        await writeFile(parsed.path, parsed.content);
+        return {
+            content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle create_directory command
  */
 export async function handleCreateDirectory(args) {
-    const parsed = CreateDirectoryArgsSchema.parse(args);
-    await createDirectory(parsed.path);
-    return {
-        content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
-    };
+    try {
+        const parsed = CreateDirectoryArgsSchema.parse(args);
+        await createDirectory(parsed.path);
+        return {
+            content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle list_directory command
  */
 export async function handleListDirectory(args) {
-    const parsed = ListDirectoryArgsSchema.parse(args);
-    const entries = await listDirectory(parsed.path);
-    return {
-        content: [{ type: "text", text: entries.join('\n') }],
-    };
+    try {
+        const parsed = ListDirectoryArgsSchema.parse(args);
+        const entries = await listDirectory(parsed.path);
+        return {
+            content: [{ type: "text", text: entries.join('\n') }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle move_file command
  */
 export async function handleMoveFile(args) {
-    const parsed = MoveFileArgsSchema.parse(args);
-    await moveFile(parsed.source, parsed.destination);
-    return {
-        content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
-    };
+    try {
+        const parsed = MoveFileArgsSchema.parse(args);
+        await moveFile(parsed.source, parsed.destination);
+        return {
+            content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle search_files command
  */
 export async function handleSearchFiles(args) {
-    const parsed = SearchFilesArgsSchema.parse(args);
-    const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
-    // Apply timeout at the handler level
-    const searchOperation = async () => {
-        return await searchFiles(parsed.path, parsed.pattern);
-    };
-    // Use withTimeout at the handler level
-    const results = await withTimeout(searchOperation(), timeoutMs, 'File search operation', [] // Empty array as default on timeout
-    );
-    if (results.length === 0) {
-        // Similar approach as in handleSearchCode
-        if (timeoutMs > 0) {
+    try {
+        const parsed = SearchFilesArgsSchema.parse(args);
+        const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
+        // Apply timeout at the handler level
+        const searchOperation = async () => {
+            return await searchFiles(parsed.path, parsed.pattern);
+        };
+        // Use withTimeout at the handler level
+        const results = await withTimeout(searchOperation(), timeoutMs, 'File search operation', [] // Empty array as default on timeout
+        );
+        if (results.length === 0) {
+            // Similar approach as in handleSearchCode
+            if (timeoutMs > 0) {
+                return {
+                    content: [{ type: "text", text: `No matches found or search timed out after ${timeoutMs}ms.` }],
+                };
+            }
             return {
-                content: [{ type: "text", text: `No matches found or search timed out after ${timeoutMs}ms.` }],
+                content: [{ type: "text", text: "No matches found" }],
             };
         }
         return {
-            content: [{ type: "text", text: "No matches found" }],
+            content: [{ type: "text", text: results.join('\n') }],
         };
     }
-    return {
-        content: [{ type: "text", text: results.join('\n') }],
-    };
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle get_file_info command
  */
 export async function handleGetFileInfo(args) {
-    const parsed = GetFileInfoArgsSchema.parse(args);
-    const info = await getFileInfo(parsed.path);
-    return {
-        content: [{
-                type: "text",
-                text: Object.entries(info)
-                    .map(([key, value]) => `${key}: ${value}`)
-                    .join('\n')
-            }],
-    };
+    try {
+        const parsed = GetFileInfoArgsSchema.parse(args);
+        const info = await getFileInfo(parsed.path);
+        return {
+            content: [{
+                    type: "text",
+                    text: Object.entries(info)
+                        .map(([key, value]) => `${key}: ${value}`)
+                        .join('\n')
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
 }
 /**
  * Handle list_allowed_directories command

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

@@ -1,18 +1,9 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle list_processes command
  */
-export declare function handleListProcesses(): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;
+export declare function handleListProcesses(): Promise<ServerResult>;
 /**
  * Handle kill_process command
  */
-export declare function handleKillProcess(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleKillProcess(args: unknown): Promise<ServerResult>;

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

@@ -1,36 +1,17 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle execute_command command
  */
-export declare function handleExecuteCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleExecuteCommand(args: unknown): Promise<ServerResult>;
 /**
  * Handle read_output command
  */
-export declare function handleReadOutput(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleReadOutput(args: unknown): Promise<ServerResult>;
 /**
  * Handle force_terminate command
  */
-export declare function handleForceTerminate(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleForceTerminate(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_sessions command
  */
-export declare function handleListSessions(): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleListSessions(): Promise<ServerResult>;

package/dist/server.js

@@ -231,7 +231,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return 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

@@ -339,7 +339,7 @@ export default async function setup() {
                         isWindows ? 
                             join(process.env.APPDATA || '', "npm", "npx.cmd").replace(/\\/g, '\\\\') : 
                             "$(which npx)",
-                        "@wonderwhy-er/desktop-commander"
+                        "@wonderwhy-er/desktop-commander@latest"
                     ],
                     "env": debugEnv
                 };
@@ -368,7 +368,7 @@ export default async function setup() {
                 serverConfig = {
                     "command": isWindows ? "npx.cmd" : "npx",
                     "args": [
-                        "@wonderwhy-er/desktop-commander"
+                        "@wonderwhy-er/desktop-commander@latest"
                     ]
                 };
             } else {

package/dist/terminal-manager.js

@@ -10,7 +10,12 @@ export class TerminalManager {
         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,

package/dist/tools/edit.d.ts

@@ -1,10 +1,12 @@
+import { ServerResult } from '../types.js';
 interface SearchReplace {
     search: string;
     replace: string;
 }
-export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<void>;
+export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<ServerResult>;
 export declare function parseEditBlock(blockContent: string): Promise<{
     filePath: string;
     searchReplace: SearchReplace;
+    error?: string;
 }>;
 export {};

package/dist/tools/edit.js

@@ -7,13 +7,18 @@ export async function performSearchReplace(filePath, block) {
     // Find first occurrence
     const searchIndex = contentStr.indexOf(block.search);
     if (searchIndex === -1) {
-        throw new Error(`Search content not found in ${filePath}`);
+        return {
+            content: [{ type: "text", text: `Search content not found in ${filePath}.` }],
+        };
     }
     // Replace content
     const newContent = contentStr.substring(0, searchIndex) +
         block.replace +
         contentStr.substring(searchIndex + block.search.length);
     await writeFile(filePath, newContent);
+    return {
+        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
+    };
 }
 export async function parseEditBlock(blockContent) {
     const lines = blockContent.split('\n');
@@ -24,7 +29,11 @@ export async function parseEditBlock(blockContent) {
     const divider = lines.indexOf('=======');
     const replaceEnd = lines.indexOf('>>>>>>> REPLACE');
     if (searchStart === -1 || divider === -1 || replaceEnd === -1) {
-        throw new Error('Invalid edit block format - missing markers');
+        return {
+            filePath: '',
+            searchReplace: { search: '', replace: '' },
+            error: 'Invalid edit block format - missing markers'
+        };
     }
     // Extract search and replace content
     const search = lines.slice(searchStart + 1, divider).join('\n');

package/dist/tools/execute.d.ts

@@ -1,21 +1,7 @@
-export declare function executeCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-export declare function readOutput(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-export declare function forceTerminate(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+import { ServerResult } from '../types.js';
+export declare function executeCommand(args: unknown): Promise<ServerResult>;
+export declare function readOutput(args: unknown): Promise<ServerResult>;
+export declare function forceTerminate(args: unknown): Promise<ServerResult>;
 export declare function listSessions(): Promise<{
     content: {
         type: string;

package/dist/tools/execute.js

@@ -6,7 +6,10 @@ export async function executeCommand(args) {
     const parsed = ExecuteCommandArgsSchema.safeParse(args);
     if (!parsed.success) {
         capture('server_execute_command_failed');
-        throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for execute_command: ${parsed.error}` }],
+            isError: true,
+        };
     }
     try {
         // Extract all commands for analytics while ensuring execution continues even if parsing fails
@@ -25,9 +28,19 @@ export async function executeCommand(args) {
         console.error('Error during command extraction:', error);
     }
     if (!commandManager.validateCommand(parsed.data.command)) {
-        throw new Error(`Command not allowed: ${parsed.data.command}`);
+        return {
+            content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
+            isError: true,
+        };
     }
     const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms);
+    // Check for error condition (pid = -1)
+    if (result.pid === -1) {
+        return {
+            content: [{ type: "text", text: result.output }],
+            isError: true,
+        };
+    }
     return {
         content: [{
                 type: "text",
@@ -38,7 +51,10 @@ export async function executeCommand(args) {
 export async function readOutput(args) {
     const parsed = ReadOutputArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for read_output: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_output: ${parsed.error}` }],
+            isError: true,
+        };
     }
     const output = terminalManager.getNewOutput(parsed.data.pid);
     return {
@@ -53,7 +69,10 @@ export async function readOutput(args) {
 export async function forceTerminate(args) {
     const parsed = ForceTerminateArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for force_terminate: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for force_terminate: ${parsed.error}` }],
+            isError: true,
+        };
     }
     const success = terminalManager.forceTerminate(parsed.data.pid);
     return {

package/dist/tools/filesystem.js

@@ -87,7 +87,8 @@ export async function validatePath(requestedPath) {
     // Execute with timeout
     const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation for ${requestedPath}`, null);
     if (result === null) {
-        throw new Error(`Path validation timed out after ${PATH_VALIDATION_TIMEOUT / 1000} seconds for: ${requestedPath}`);
+        // Return a path with an error indicator instead of throwing
+        return `__ERROR__: Path validation timed out after ${PATH_VALIDATION_TIMEOUT / 1000} seconds for: ${requestedPath}`;
     }
     return result;
 }
@@ -141,11 +142,20 @@ export async function readFileFromUrl(url, returnMetadata) {
     catch (error) {
         // Clear the timeout to prevent memory leaks
         clearTimeout(timeoutId);
-        // Improve error message for timeout/abort cases
-        if (error instanceof DOMException && error.name === 'AbortError') {
-            throw new Error(`URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`);
+        // Return error information instead of throwing
+        const errorMessage = error instanceof DOMException && error.name === 'AbortError'
+            ? `URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`
+            : `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`;
+        if (returnMetadata === true) {
+            return {
+                content: `Error: ${errorMessage}`,
+                mimeType: 'text/plain',
+                isImage: false
+            };
+        }
+        else {
+            return `Error: ${errorMessage}`;
         }
-        throw new Error(`Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 /**

package/dist/tools/process.d.ts

@@ -1,12 +1,3 @@
-export declare function listProcesses(): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;
-export declare function killProcess(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+import { ServerResult } from '../types.js';
+export declare function listProcesses(): Promise<ServerResult>;
+export declare function killProcess(args: unknown): Promise<ServerResult>;

package/dist/tools/process.js

@@ -27,13 +27,19 @@ export async function listProcesses() {
         };
     }
     catch (error) {
-        throw new Error('Failed to list processes');
+        return {
+            content: [{ type: "text", text: `Error: Failed to list processes: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
     }
 }
 export async function killProcess(args) {
     const parsed = KillProcessArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for kill_process: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for kill_process: ${parsed.error}` }],
+            isError: true,
+        };
     }
     try {
         process.kill(parsed.data.pid);
@@ -42,6 +48,9 @@ export async function killProcess(args) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to kill process: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error: Failed to kill process: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
     }
 }

package/dist/types.d.ts

@@ -29,3 +29,15 @@ export interface CompletedSession {
     startTime: Date;
     endTime: Date;
 }
+export interface ServerResponseContent {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+export interface ServerResult {
+    content: ServerResponseContent[];
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+export type ToolHandler<T = unknown> = (args: T) => Promise<ServerResult>;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.32";
+export declare const VERSION = "0.1.34";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.32';
+export const VERSION = '0.1.34';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",