@wonderwhy-er/desktop-commander 0.2.15 → 0.2.17

package/dist/tools/filesystem.js

@@ -757,10 +757,58 @@ export async function createDirectory(dirPath) {
     const validPath = await validatePath(dirPath);
     await fs.mkdir(validPath, { recursive: true });
 }
-export async function listDirectory(dirPath) {
+export async function listDirectory(dirPath, depth = 2) {
     const validPath = await validatePath(dirPath);
-    const entries = await fs.readdir(validPath, { withFileTypes: true });
-    return entries.map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`);
+    const results = [];
+    const MAX_NESTED_ITEMS = 100; // Maximum items to show per nested directory
+    async function listRecursive(currentPath, currentDepth, relativePath = '', isTopLevel = true) {
+        if (currentDepth <= 0)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true });
+        }
+        catch (error) {
+            // If we can't read this directory (permission denied), show as denied
+            const displayPath = relativePath || path.basename(currentPath);
+            results.push(`[DENIED] ${displayPath}`);
+            return;
+        }
+        // Apply filtering for nested directories (not top level)
+        const totalEntries = entries.length;
+        let entriesToShow = entries;
+        let filteredCount = 0;
+        if (!isTopLevel && totalEntries > MAX_NESTED_ITEMS) {
+            entriesToShow = entries.slice(0, MAX_NESTED_ITEMS);
+            filteredCount = totalEntries - MAX_NESTED_ITEMS;
+        }
+        for (const entry of entriesToShow) {
+            const fullPath = path.join(currentPath, entry.name);
+            const displayPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+            // Add this entry to results
+            results.push(`${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${displayPath}`);
+            // If it's a directory and we have depth remaining, recurse
+            if (entry.isDirectory() && currentDepth > 1) {
+                try {
+                    // Validate the path before recursing
+                    await validatePath(fullPath);
+                    await listRecursive(fullPath, currentDepth - 1, displayPath, false);
+                }
+                catch (error) {
+                    // If validation fails or we can't access it, it will be marked as denied
+                    // when we try to read it in the recursive call
+                    continue;
+                }
+            }
+        }
+        // Add warning message if items were filtered
+        if (filteredCount > 0) {
+            const displayPath = relativePath || path.basename(currentPath);
+            results.push(`[WARNING] ${displayPath}: ${filteredCount} items hidden (showing first ${MAX_NESTED_ITEMS} of ${totalEntries} total)`);
+        }
+    }
+    await listRecursive(validPath, depth, '', true);
+    return results;
 }
 export async function moveFile(sourcePath, destinationPath) {
     const validSourcePath = await validatePath(sourcePath);

package/dist/tools/schemas.d.ts

@@ -94,10 +94,13 @@ export declare const CreateDirectoryArgsSchema: z.ZodObject<{
 }>;
 export declare const ListDirectoryArgsSchema: z.ZodObject<{
     path: z.ZodString;
+    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
+    depth: number;
 }, {
     path: string;
+    depth?: number | undefined;
 }>;
 export declare const MoveFileArgsSchema: z.ZodObject<{
     source: z.ZodString;
@@ -221,3 +224,16 @@ export declare const GetPromptsArgsSchema: z.ZodObject<{
     category?: string | undefined;
     promptId?: string | undefined;
 }>;
+export declare const GetRecentToolCallsArgsSchema: z.ZodObject<{
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    toolName: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    maxResults: number;
+    toolName?: string | undefined;
+    since?: string | undefined;
+}, {
+    maxResults?: number | undefined;
+    toolName?: string | undefined;
+    since?: string | undefined;
+}>;

package/dist/tools/schemas.js

@@ -50,6 +50,7 @@ export const CreateDirectoryArgsSchema = z.object({
 });
 export const ListDirectoryArgsSchema = z.object({
     path: z.string(),
+    depth: z.number().optional().default(2),
 });
 export const MoveFileArgsSchema = z.object({
     source: z.string(),
@@ -112,3 +113,9 @@ export const GetPromptsArgsSchema = z.object({
     category: z.string().optional(),
     promptId: z.string().optional(),
 });
+// Tool history schema
+export const GetRecentToolCallsArgsSchema = z.object({
+    maxResults: z.number().min(1).max(1000).optional().default(50),
+    toolName: z.string().optional(),
+    since: z.string().datetime().optional(),
+});

package/dist/utils/system-info.d.ts

@@ -29,6 +29,18 @@ export interface SystemInfo {
     isMacOS: boolean;
     isLinux: boolean;
     docker: ContainerInfo;
+    isDXT: boolean;
+    nodeInfo?: {
+        version: string;
+        path: string;
+        npmVersion?: string;
+    };
+    processInfo: {
+        pid: number;
+        arch: string;
+        platform: string;
+        versions: NodeJS.ProcessVersions;
+    };
     examplePaths: {
         home: string;
         temp: string;

package/dist/utils/system-info.js

@@ -305,6 +305,27 @@ function getContainerEnvironment(containerType) {
     }
     return Object.keys(env).length > 0 ? env : undefined;
 }
+/**
+ * Detect Node.js installation and version from current process
+ */
+function detectNodeInfo() {
+    try {
+        // Get Node.js version from current process
+        const version = process.version.replace('v', ''); // Remove 'v' prefix
+        // Get Node.js executable path from current process
+        const path = process.execPath;
+        // Get npm version from environment if available
+        const npmVersion = process.env.npm_version;
+        return {
+            version,
+            path,
+            ...(npmVersion && { npmVersion })
+        };
+    }
+    catch (error) {
+        return undefined;
+    }
+}
 /**
  * Get comprehensive system information for tool prompts
  */
@@ -397,6 +418,15 @@ export function getSystemInfo() {
             examplePaths.accessible = mountPoints.map(mount => mount.containerPath);
         }
     }
+    // Detect Node.js installation from current process
+    const nodeInfo = detectNodeInfo();
+    // Get process information
+    const processInfo = {
+        pid: process.pid,
+        arch: process.arch,
+        platform: process.platform,
+        versions: process.versions
+    };
     return {
         platform,
         platformName,
@@ -415,6 +445,9 @@ export function getSystemInfo() {
             mountPoints,
             containerEnvironment: getContainerEnvironment(containerDetection.containerType)
         },
+        isDXT: !!process.env.MCP_DXT,
+        nodeInfo,
+        processInfo,
         examplePaths
     };
 }
@@ -545,33 +578,51 @@ LINUX-SPECIFIC NOTES:
  * Get common development tool guidance based on OS
  */
 export function getDevelopmentToolGuidance(systemInfo) {
-    const { isWindows, isMacOS, isLinux, platformName } = systemInfo;
+    const { isWindows, isMacOS, isLinux, platformName, nodeInfo, processInfo } = systemInfo;
+    // Add detected Node.js info to guidance
+    const nodeGuidance = nodeInfo
+        ? `Node.js: v${nodeInfo.version} (${nodeInfo.path})${nodeInfo.npmVersion ? ` | npm: v${nodeInfo.npmVersion}` : ''}`
+        : 'Node.js: Not detected';
+    // Add process environment info
+    const envInfo = `
+Current Process Environment:
+- Node: v${processInfo.versions.node}
+- V8: v${processInfo.versions.v8}
+- Architecture: ${processInfo.arch}
+- Platform: ${processInfo.platform}
+- Process ID: ${processInfo.pid}`;
     if (isWindows) {
         return `
 COMMON WINDOWS DEVELOPMENT TOOLS:
-- Node.js: Usually installed globally, accessible from any shell
+- ${nodeGuidance}
 - Python: May be 'python' or 'py' command, check both
 - Git: Git Bash provides Unix-like environment
 - WSL: Windows Subsystem for Linux available for Unix tools
-- Visual Studio tools: cl, msbuild for C++ compilation`;
+- Visual Studio tools: cl, msbuild for C++ compilation
+
+${envInfo}`;
     }
     else if (isMacOS) {
         return `
 COMMON MACOS DEVELOPMENT TOOLS:
 - Xcode Command Line Tools: Required for many development tools
 - Homebrew: Primary package manager for development tools
+- ${nodeGuidance}
 - Python: Usually python3, check if python points to Python 2
-- Node.js: Available via brew or direct installer
-- Ruby: System Ruby available, rbenv/rvm for version management`;
+- Ruby: System Ruby available, rbenv/rvm for version management
+
+${envInfo}`;
     }
     else {
         return `
 COMMON LINUX DEVELOPMENT TOOLS:
 - Package managers: Install tools via distribution package manager
 - Python: Usually python3, python may point to Python 2
-- Node.js: Available via package manager or NodeSource repository
+- ${nodeGuidance}
 - Build tools: gcc, make typically available or easily installed
-- Container tools: docker, podman common for development`;
+- Container tools: docker, podman common for development
+
+${envInfo}`;
     }
 }
 /**

package/dist/utils/toolHistory.d.ts

@@ -0,0 +1,73 @@
+import { ServerResult } from '../types.js';
+export interface ToolCallRecord {
+    timestamp: string;
+    toolName: string;
+    arguments: any;
+    output: ServerResult;
+    duration?: number;
+}
+interface FormattedToolCallRecord extends Omit<ToolCallRecord, 'timestamp'> {
+    timestamp: string;
+}
+declare class ToolHistory {
+    private history;
+    private readonly MAX_ENTRIES;
+    private readonly historyFile;
+    private writeQueue;
+    private isWriting;
+    private writeInterval?;
+    constructor();
+    /**
+     * Load history from disk (all instances share the same file)
+     */
+    private loadFromDisk;
+    /**
+     * Trim history file to prevent it from growing indefinitely
+     */
+    private trimHistoryFile;
+    /**
+     * Async write processor - batches writes to avoid blocking
+     */
+    private startWriteProcessor;
+    /**
+     * Flush queued writes to disk
+     */
+    private flushToDisk;
+    /**
+     * Add a tool call to history
+     */
+    addCall(toolName: string, args: any, output: ServerResult, duration?: number): void;
+    /**
+     * Get recent tool calls with filters
+     */
+    getRecentCalls(options: {
+        maxResults?: number;
+        toolName?: string;
+        since?: string;
+    }): ToolCallRecord[];
+    /**
+     * Get recent calls formatted with local timezone
+     */
+    getRecentCallsFormatted(options: {
+        maxResults?: number;
+        toolName?: string;
+        since?: string;
+    }): FormattedToolCallRecord[];
+    /**
+     * Get current stats
+     */
+    getStats(): {
+        totalEntries: number;
+        oldestEntry: string;
+        newestEntry: string;
+        historyFile: string;
+        queuedWrites: number;
+    };
+    /**
+     * Cleanup method - clears interval and flushes pending writes
+     * Call this during shutdown or in tests
+     */
+    cleanup(): Promise<void>;
+}
+export declare const toolHistory: ToolHistory;
+export {};

package/dist/utils/toolHistory.js

@@ -0,0 +1,197 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Format timestamp in local timezone for display
+function formatLocalTimestamp(isoTimestamp) {
+    const date = new Date(isoTimestamp);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false
+    });
+}
+class ToolHistory {
+    constructor() {
+        this.history = [];
+        this.MAX_ENTRIES = 1000;
+        this.writeQueue = [];
+        this.isWriting = false;
+        // Store history in same directory as config to keep everything together
+        const historyDir = path.join(os.homedir(), '.claude-server-commander');
+        // Ensure directory exists
+        if (!fs.existsSync(historyDir)) {
+            fs.mkdirSync(historyDir, { recursive: true });
+        }
+        // Use append-only JSONL format (JSON Lines)
+        this.historyFile = path.join(historyDir, 'tool-history.jsonl');
+        // Load existing history on startup
+        this.loadFromDisk();
+        // Start async write processor
+        this.startWriteProcessor();
+    }
+    /**
+     * Load history from disk (all instances share the same file)
+     */
+    loadFromDisk() {
+        try {
+            if (!fs.existsSync(this.historyFile)) {
+                console.error('[ToolHistory] No history file found, starting fresh');
+                return;
+            }
+            const content = fs.readFileSync(this.historyFile, 'utf-8');
+            const lines = content.trim().split('\n').filter(line => line.trim());
+            // Parse each line as JSON
+            const records = [];
+            for (const line of lines) {
+                try {
+                    records.push(JSON.parse(line));
+                }
+                catch (e) {
+                    console.error('[ToolHistory] Failed to parse line:', line);
+                }
+            }
+            // Keep only last 1000 entries
+            this.history = records.slice(-this.MAX_ENTRIES);
+            console.error(`[ToolHistory] Loaded ${this.history.length} entries from disk`);
+            // If file is getting too large, trim it
+            if (lines.length > this.MAX_ENTRIES * 2) {
+                this.trimHistoryFile();
+            }
+        }
+        catch (error) {
+            console.error('[ToolHistory] Failed to load history:', error);
+        }
+    }
+    /**
+     * Trim history file to prevent it from growing indefinitely
+     */
+    trimHistoryFile() {
+        try {
+            console.error('[ToolHistory] Trimming history file...');
+            // Keep last 1000 entries in memory
+            const keepEntries = this.history.slice(-this.MAX_ENTRIES);
+            // Write them back
+            const lines = keepEntries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+            fs.writeFileSync(this.historyFile, lines, 'utf-8');
+            console.error(`[ToolHistory] Trimmed to ${keepEntries.length} entries`);
+        }
+        catch (error) {
+            console.error('[ToolHistory] Failed to trim history file:', error);
+        }
+    }
+    /**
+     * Async write processor - batches writes to avoid blocking
+     */
+    startWriteProcessor() {
+        this.writeInterval = setInterval(() => {
+            if (this.writeQueue.length > 0 && !this.isWriting) {
+                this.flushToDisk();
+            }
+        }, 1000); // Flush every second
+        // Prevent interval from keeping process alive during shutdown/tests
+        this.writeInterval.unref();
+    }
+    /**
+     * Flush queued writes to disk
+     */
+    async flushToDisk() {
+        if (this.isWriting || this.writeQueue.length === 0)
+            return;
+        this.isWriting = true;
+        const toWrite = [...this.writeQueue];
+        this.writeQueue = [];
+        try {
+            // Append to file (atomic append operation)
+            const lines = toWrite.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+            fs.appendFileSync(this.historyFile, lines, 'utf-8');
+        }
+        catch (error) {
+            console.error('[ToolHistory] Failed to write to disk:', error);
+            // Put back in queue on failure
+            this.writeQueue.unshift(...toWrite);
+        }
+        finally {
+            this.isWriting = false;
+        }
+    }
+    /**
+     * Add a tool call to history
+     */
+    addCall(toolName, args, output, duration) {
+        const record = {
+            timestamp: new Date().toISOString(),
+            toolName,
+            arguments: args,
+            output,
+            duration
+        };
+        this.history.push(record);
+        // Keep only last 1000 in memory
+        if (this.history.length > this.MAX_ENTRIES) {
+            this.history.shift();
+        }
+        // Queue for async write
+        this.writeQueue.push(record);
+    }
+    /**
+     * Get recent tool calls with filters
+     */
+    getRecentCalls(options) {
+        let results = [...this.history];
+        // Filter by tool name
+        if (options.toolName) {
+            results = results.filter(r => r.toolName === options.toolName);
+        }
+        // Filter by timestamp
+        if (options.since) {
+            const sinceDate = new Date(options.since);
+            results = results.filter(r => new Date(r.timestamp) >= sinceDate);
+        }
+        // Limit results (default 50, max 1000)
+        const limit = Math.min(options.maxResults || 50, 1000);
+        return results.slice(-limit);
+    }
+    /**
+     * Get recent calls formatted with local timezone
+     */
+    getRecentCallsFormatted(options) {
+        const calls = this.getRecentCalls(options);
+        // Format timestamps to local timezone
+        return calls.map(call => ({
+            ...call,
+            timestamp: formatLocalTimestamp(call.timestamp)
+        }));
+    }
+    /**
+     * Get current stats
+     */
+    getStats() {
+        return {
+            totalEntries: this.history.length,
+            oldestEntry: this.history[0]?.timestamp,
+            newestEntry: this.history[this.history.length - 1]?.timestamp,
+            historyFile: this.historyFile,
+            queuedWrites: this.writeQueue.length
+        };
+    }
+    /**
+     * Cleanup method - clears interval and flushes pending writes
+     * Call this during shutdown or in tests
+     */
+    async cleanup() {
+        // Clear the interval
+        if (this.writeInterval) {
+            clearInterval(this.writeInterval);
+            this.writeInterval = undefined;
+        }
+        // Flush any remaining writes
+        if (this.writeQueue.length > 0) {
+            await this.flushToDisk();
+        }
+    }
+}
+export const toolHistory = new ToolHistory();

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.15";
+export declare const VERSION = "0.2.17";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.15';
+export const VERSION = '0.2.17';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -42,6 +42,11 @@
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
     "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "build:mcpb": "node scripts/build-mcpb.cjs",
+    "release": "node scripts/publish-release.cjs",
+    "release:minor": "node scripts/publish-release.cjs --minor",
+    "release:major": "node scripts/publish-release.cjs --major",
+    "release:dry": "node scripts/publish-release.cjs --dry-run",
     "logs:view": "npm run build && node scripts/view-fuzzy-logs.js",
     "logs:analyze": "npm run build && node scripts/analyze-fuzzy-logs.js",
     "logs:clear": "npm run build && node scripts/clear-fuzzy-logs.js",