@wonderwhy-er/desktop-commander 0.2.15 → 0.2.17

package/dist/server.js

@@ -8,7 +8,7 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
-import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -16,6 +16,7 @@ import { getPrompts } from './tools/prompts.js';
 import { trackToolCall } from './utils/trackTools.js';
 import { usageTracker } from './utils/usageTracker.js';
 import { processDockerPrompt } from './utils/dockerPrompt.js';
+import { toolHistory } from './utils/toolHistory.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
@@ -95,15 +96,27 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
 // Export current client info for access by other modules
 export { currentClient };
 deferLog('info', 'Setting up request handlers...');
+/**
+ * Check if a tool should be included based on current client
+ */
+function shouldIncludeTool(toolName) {
+    // Exclude give_feedback_to_desktop_commander for desktop-commander client
+    if (toolName === 'give_feedback_to_desktop_commander' && currentClient?.name === 'desktop-commander') {
+        return false;
+    }
+    // Add more conditional tool logic here as needed
+    // Example: if (toolName === 'some_tool' && currentClient?.name === 'some_client') return false;
+    return true;
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
         logToStderr('debug', 'Generating tools list...');
-        return {
-            tools: [
-                // Configuration tools
-                {
-                    name: "get_config",
-                    description: `
+        // Build complete tools array
+        const allTools = [
+            // 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)
@@ -116,11 +129,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - version (version of the DesktopCommander)
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                annotations: {
+                    title: "Get Configuration",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "set_config_value",
-                    description: `
+            },
+            {
+                name: "set_config_value",
+                description: `
                         Set a specific configuration value by key.
                         
                         WARNING: Should be used in a separate chat from file operations and 
@@ -138,12 +155,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         to the entire file system, regardless of the operating system.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
+                inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
+                annotations: {
+                    title: "Set Configuration Value",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                // Filesystem tools
-                {
-                    name: "read_file",
-                    description: `
+            },
+            // Filesystem tools
+            {
+                name: "read_file",
+                description: `
                         Read the contents of a file from the file system or a URL with optional offset and length parameters.
                         
                         Prefer this over 'execute_command' with cat/type for viewing files.
@@ -176,11 +199,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                annotations: {
+                    title: "Read File or URL",
+                    readOnlyHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "read_multiple_files",
-                    description: `
+            },
+            {
+                name: "read_multiple_files",
+                description: `
                         Read the contents of multiple files simultaneously.
                         
                         Each file's content is returned with its path as a reference.
@@ -192,11 +220,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
+                inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
+                annotations: {
+                    title: "Read Multiple Files",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "write_file",
-                    description: `
+            },
+            {
+                name: "write_file",
+                description: `
                         Write or append to file contents. 
 
                         CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
@@ -225,11 +257,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                annotations: {
+                    title: "Write File",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "create_directory",
-                    description: `
+            },
+            {
+                name: "create_directory",
+                description: `
                         Create a new directory or ensure a directory exists.
                         
                         Can create multiple nested directories in one operation.
@@ -237,24 +275,49 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
-                },
-                {
-                    name: "list_directory",
-                    description: `
+                inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
+            },
+            {
+                name: "list_directory",
+                description: `
                         Get a detailed listing of all files and directories in a specified path.
                         
                         Use this instead of 'execute_command' with ls/dir commands.
                         Results distinguish between files and directories with [FILE] and [DIR] prefixes.
+                        
+                        Supports recursive listing with the 'depth' parameter (default: 2):
+                        - depth=1: Only direct contents of the directory
+                        - depth=2: Contents plus one level of subdirectories
+                        - depth=3+: Multiple levels deep
+                        
+                        CONTEXT OVERFLOW PROTECTION:
+                        - Top-level directory shows ALL items
+                        - Nested directories are limited to 100 items maximum per directory
+                        - When a nested directory has more than 100 items, you'll see a warning like:
+                          [WARNING] node_modules: 500 items hidden (showing first 100 of 600 total)
+                        - This prevents overwhelming the context with large directories like node_modules
+                        
+                        Results show full relative paths from the root directory being listed.
+                        Example output with depth=2:
+                        [DIR] src
+                        [FILE] src/index.ts
+                        [DIR] src/tools
+                        [FILE] src/tools/filesystem.ts
+                        
+                        If a directory cannot be accessed, it will show [DENIED] instead.
                         Only works within allowed directories.
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                annotations: {
+                    title: "List Directory Contents",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "move_file",
-                    description: `
+            },
+            {
+                name: "move_file",
+                description: `
                         Move or rename files and directories.
                         
                         Can move files between directories and rename them in a single operation.
@@ -262,11 +325,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(MoveFileArgsSchema),
+                inputSchema: zodToJsonSchema(MoveFileArgsSchema),
+                annotations: {
+                    title: "Move/Rename File",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "start_search",
-                    description: `
+            },
+            {
+                name: "start_search",
+                description: `
                         Start a streaming search that can return results progressively.
                         
                         SEARCH STRATEGY GUIDE:
@@ -345,11 +414,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StartSearchArgsSchema),
-                },
-                {
-                    name: "get_more_search_results",
-                    description: `
+                inputSchema: zodToJsonSchema(StartSearchArgsSchema),
+            },
+            {
+                name: "get_more_search_results",
+                description: `
                         Get more results from an active search with offset-based pagination.
                         
                         Supports partial result reading with:
@@ -371,11 +440,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         results from a search started with start_search.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
+                inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
+                annotations: {
+                    title: "Get Search Results",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "stop_search",
-                    description: `
+            },
+            {
+                name: "stop_search",
+                description: `
                         Stop an active search.
                         
                         Stops the background search process gracefully. Use this when you've found
@@ -386,11 +459,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         automatically cleaned up after 5 minutes.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StopSearchArgsSchema),
-                },
-                {
-                    name: "list_searches",
-                    description: `
+                inputSchema: zodToJsonSchema(StopSearchArgsSchema),
+            },
+            {
+                name: "list_searches",
+                description: `
                         List all active searches.
                         
                         Shows search IDs, search types, patterns, status, and runtime.
@@ -398,11 +471,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         multiple concurrent searches.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
+                inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
+                annotations: {
+                    title: "List Active Searches",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "get_file_info",
-                    description: `
+            },
+            {
+                name: "get_file_info",
+                description: `
                         Retrieve detailed metadata about a file or directory including:
                         - size
                         - creation time
@@ -417,13 +494,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
+                inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
+                annotations: {
+                    title: "Get File Information",
+                    readOnlyHint: true,
                 },
-                // Note: list_allowed_directories removed - use get_config to check allowedDirectories
-                // Text editing tools
-                {
-                    name: "edit_block",
-                    description: `
+            },
+            // 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 PRACTICE: Make multiple small, focused edits rather than one large edit.
@@ -456,12 +537,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                annotations: {
+                    title: "Edit Text Block",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                // Terminal tools
-                {
-                    name: "start_process",
-                    description: `
+            },
+            // Terminal tools
+            {
+                name: "start_process",
+                description: `
                         Start a new terminal process with intelligent state detection.
                         
                         PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
@@ -512,11 +599,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StartProcessArgsSchema),
+                inputSchema: zodToJsonSchema(StartProcessArgsSchema),
+                annotations: {
+                    title: "Start Terminal Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "read_process_output",
-                    description: `
+            },
+            {
+                name: "read_process_output",
+                description: `
                         Read output from a running process with intelligent completion detection.
                         
                         Automatically detects when process is ready for more input instead of timing out.
@@ -539,11 +632,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Timeout reached (may still be running)
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
+                inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
+                annotations: {
+                    title: "Read Process Output",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "interact_with_process",
-                    description: `
+            },
+            {
+                name: "interact_with_process",
+                description: `
                         Send input to a running process and automatically receive the response.
                         
                         CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
@@ -591,19 +688,31 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(InteractWithProcessArgsSchema),
+                inputSchema: zodToJsonSchema(InteractWithProcessArgsSchema),
+                annotations: {
+                    title: "Send Input to Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "force_terminate",
-                    description: `
+            },
+            {
+                name: "force_terminate",
+                description: `
                         Force terminate a running terminal session.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
+                inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
+                annotations: {
+                    title: "Force Terminate Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "list_sessions",
-                    description: `
+            },
+            {
+                name: "list_sessions",
+                description: `
                         List all active terminal sessions.
                         
                         Shows session status including:
@@ -617,41 +726,80 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - Long runtime with blocked status may indicate stuck process
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
+                inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
+                annotations: {
+                    title: "List Terminal Sessions",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "list_processes",
-                    description: `
+            },
+            {
+                name: "list_processes",
+                description: `
                         List all running processes.
                         
                         Returns process information including PID, command name, CPU usage, and memory usage.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
+                inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
+                annotations: {
+                    title: "List Running Processes",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "kill_process",
-                    description: `
+            },
+            {
+                name: "kill_process",
+                description: `
                         Terminate a running process by PID.
                         
                         Use with caution as this will forcefully terminate the specified process.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(KillProcessArgsSchema),
+                inputSchema: zodToJsonSchema(KillProcessArgsSchema),
+                annotations: {
+                    title: "Kill Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "get_usage_stats",
-                    description: `
+            },
+            {
+                name: "get_usage_stats",
+                description: `
                         Get usage statistics for debugging and analysis.
                         
                         Returns summary of tool usage, success/failure rates, and performance metrics.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetUsageStatsArgsSchema),
+                inputSchema: zodToJsonSchema(GetUsageStatsArgsSchema),
+                annotations: {
+                    title: "Get Usage Statistics",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "give_feedback_to_desktop_commander",
-                    description: `
+            },
+            {
+                name: "get_recent_tool_calls",
+                description: `
+                        Get recent tool call history with their arguments and outputs.
+                        Returns chronological list of tool calls made during this session.
+                        
+                        Useful for:
+                        - Onboarding new chats about work already done
+                        - Recovering context after chat history loss
+                        - Debugging tool call sequences
+                        
+                        Note: Does not track its own calls or other meta/query tools.
+                        History kept in memory (last 1000 calls, lost on restart).
+                        
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                inputSchema: zodToJsonSchema(GetRecentToolCallsArgsSchema),
+                annotations: {
+                    title: "Get Recent Tool Calls",
+                    readOnlyHint: true,
+                },
+            },
+            {
+                name: "give_feedback_to_desktop_commander",
+                description: `
                         Open feedback form in browser to provide feedback about Desktop Commander.
                         
                         IMPORTANT: This tool simply opens the feedback form - no pre-filling available.
@@ -684,11 +832,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         No parameters are needed - just call the tool to open the form.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GiveFeedbackArgsSchema),
-                },
-                {
-                    name: "get_prompts",
-                    description: `
+                inputSchema: zodToJsonSchema(GiveFeedbackArgsSchema),
+            },
+            {
+                name: "get_prompts",
+                description: `
                         Browse and retrieve curated Desktop Commander prompts for various tasks and workflows.
                         
                         IMPORTANT: When displaying prompt lists to users, do NOT show the internal prompt IDs (like 'onb_001'). 
@@ -718,9 +866,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Perfect for discovering proven workflows and getting started with Desktop Commander.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
-                },
-            ],
+                inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
+            },
+        ];
+        // Filter tools based on current client
+        const filteredTools = allTools.filter(tool => shouldIncludeTool(tool.name));
+        logToStderr('debug', `Returning ${filteredTools.length} tools (filtered from ${allTools.length} total) for client: ${currentClient?.name || 'unknown'}`);
+        return {
+            tools: filteredTools,
         };
     }
     catch (error) {
@@ -731,6 +884,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    const startTime = Date.now();
     try {
         // Prepare telemetry data - add config key for set_config_value
         const telemetryData = { name };
@@ -867,6 +1021,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 break;
+            case "get_recent_tool_calls":
+                try {
+                    result = await handlers.handleGetRecentToolCalls(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_recent_tool_calls handler: ${error}` });
+                    result = {
+                        content: [{ type: "text", text: `Error: Failed to get tool call history` }],
+                        isError: true,
+                    };
+                }
+                break;
             case "give_feedback_to_desktop_commander":
                 try {
                     result = await giveFeedbackToDesktopCommander(args);
@@ -947,6 +1113,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: true,
                 };
         }
+        // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
+        const duration = Date.now() - startTime;
+        const EXCLUDED_TOOLS = [
+            'get_recent_tool_calls'
+        ];
+        if (!EXCLUDED_TOOLS.includes(name)) {
+            toolHistory.addCall(name, args, result, duration);
+        }
         // Track success or failure based on result
         if (result.isError) {
             await usageTracker.trackFailure(name);

package/dist/tools/config.js

@@ -11,19 +11,21 @@ export async function getConfig() {
         const config = await configManager.getConfig();
         // Add system information and current client to the config response
         const systemInfo = getSystemInfo();
+        // Get memory usage
+        const memoryUsage = process.memoryUsage();
+        const memory = {
+            rss: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`,
+            heapTotal: `${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+            heapUsed: `${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+            external: `${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB`,
+            arrayBuffers: `${(memoryUsage.arrayBuffers / 1024 / 1024).toFixed(2)} MB`
+        };
         const configWithSystemInfo = {
             ...config,
             currentClient,
             systemInfo: {
-                platform: systemInfo.platform,
-                platformName: systemInfo.platformName,
-                defaultShell: systemInfo.defaultShell,
-                pathSeparator: systemInfo.pathSeparator,
-                isWindows: systemInfo.isWindows,
-                isMacOS: systemInfo.isMacOS,
-                isLinux: systemInfo.isLinux,
-                docker: systemInfo.docker,
-                examplePaths: systemInfo.examplePaths
+                ...systemInfo,
+                memory
             }
         };
         console.error(`getConfig result: ${JSON.stringify(configWithSystemInfo, null, 2)}`);

package/dist/tools/filesystem.d.ts

@@ -56,7 +56,7 @@ export interface MultiFileResult {
 }
 export declare function readMultipleFiles(paths: string[]): Promise<MultiFileResult[]>;
 export declare function createDirectory(dirPath: string): Promise<void>;
-export declare function listDirectory(dirPath: string): Promise<string[]>;
+export declare function listDirectory(dirPath: string, depth?: number): Promise<string[]>;
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;
 export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
 export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;