@wonderwhy-er/desktop-commander 0.2.16 → 0.2.18-alpha.0

package/dist/setup-claude-server.js

@@ -44,7 +44,7 @@ async function initConfigFile() {
         // Ensure config directory exists
         const configDir = path.dirname(CONFIG_FILE);
         if (!existsSync(configDir)) {
-            await mkdir(configDir, { recursive: true });
+            mkdirSync(configDir, { recursive: true });
         }
 
         // Check if config file exists
@@ -206,6 +206,28 @@ function detectShell() {
   return 'unknown-shell';
 }
 
+// Function to get the package spec that was used to run this script
+function getPackageSpec() {
+  // Check if running via npx - look for the package spec in process.argv
+  // e.g., npx @wonderwhy-er/desktop-commander@0.2.18-alpha setup
+  const argv = process.argv;
+  
+  // Look for the package name in argv
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.includes('@wonderwhy-er/desktop-commander')) {
+      // Extract just the package spec (e.g., @wonderwhy-er/desktop-commander@0.2.18-alpha)
+      const match = arg.match(/(@wonderwhy-er\/desktop-commander(@[^\/\s]+)?)/);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  
+  // Fallback to @latest if we can't detect
+  return '@wonderwhy-er/desktop-commander@latest';
+}
+
 // Function to determine execution context
 function getExecutionContext() {
   // Check if running from npx
@@ -728,6 +750,7 @@ export default async function setup() {
                         "DEBUG": "*"
                     };
 
+                    const packageSpec = getPackageSpec();
                     serverConfig = {
                         "command": isWindows ? "node.exe" : "node",
                         "args": [
@@ -735,11 +758,11 @@ export default async function setup() {
                             isWindows ?
                                 join(process.env.APPDATA || '', "npm", "npx.cmd").replace(/\\/g, '\\\\') :
                                 "$(which npx)",
-                            "@wonderwhy-er/desktop-commander@latest"
+                            packageSpec
                         ],
                         "env": debugEnv
                     };
-                    await trackEvent('npx_setup_config_debug_npx');
+                    await trackEvent('npx_setup_config_debug_npx', { packageSpec });
                 } else {
                     // Debug with local installation path
                     const indexPath = join(__dirname, 'dist', 'index.js');
@@ -763,13 +786,14 @@ export default async function setup() {
             } else {
                 // Standard configuration without debug
                 if (isNpx) {
+                    const packageSpec = getPackageSpec();
                     serverConfig = {
                         "command": isWindows ? "npx.cmd" : "npx",
                         "args": [
-                            "@wonderwhy-er/desktop-commander@latest"
+                            packageSpec
                         ]
                     };
-                    await trackEvent('npx_setup_config_standard_npx');
+                    await trackEvent('npx_setup_config_standard_npx', { packageSpec });
                 } else {
                     // For local installation, use absolute path to handle Windows properly
                     const indexPath = join(__dirname, 'dist', 'index.js');

package/dist/terminal-manager.d.ts

@@ -16,7 +16,7 @@ export declare class TerminalManager {
      * @returns Whether input was successfully sent
      */
     sendInputToProcess(pid: number, input: string): boolean;
-    executeCommand(command: string, timeoutMs?: number, shell?: string): Promise<CommandExecutionResult>;
+    executeCommand(command: string, timeoutMs?: number, shell?: string, collectTiming?: boolean): Promise<CommandExecutionResult>;
     getNewOutput(pid: number): string | null;
     /**
    * Get a session by PID

package/dist/terminal-manager.js

@@ -33,7 +33,7 @@ export class TerminalManager {
             return false;
         }
     }
-    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell) {
+    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell, collectTiming = false) {
         // Get the shell from config if not specified
         let shellToUse = shell;
         if (!shellToUse) {
@@ -81,6 +81,12 @@ export class TerminalManager {
             startTime: new Date()
         };
         this.sessions.set(childProcess.pid, session);
+        // Timing telemetry
+        const startTime = Date.now();
+        let firstOutputTime;
+        let lastOutputTime;
+        const outputEvents = [];
+        let exitReason = 'timeout';
         return new Promise((resolve) => {
             let resolved = false;
             let periodicCheck = null;
@@ -92,15 +98,47 @@ export class TerminalManager {
                 resolved = true;
                 if (periodicCheck)
                     clearInterval(periodicCheck);
+                // Add timing info if requested
+                if (collectTiming) {
+                    const endTime = Date.now();
+                    result.timingInfo = {
+                        startTime,
+                        endTime,
+                        totalDurationMs: endTime - startTime,
+                        exitReason,
+                        firstOutputTime,
+                        lastOutputTime,
+                        timeToFirstOutputMs: firstOutputTime ? firstOutputTime - startTime : undefined,
+                        outputEvents: outputEvents.length > 0 ? outputEvents : undefined
+                    };
+                }
                 resolve(result);
             };
             childProcess.stdout.on('data', (data) => {
                 const text = data.toString();
+                const now = Date.now();
+                if (!firstOutputTime)
+                    firstOutputTime = now;
+                lastOutputTime = now;
                 output += text;
                 session.lastOutput += text;
+                // Record output event if collecting timing
+                if (collectTiming) {
+                    outputEvents.push({
+                        timestamp: now,
+                        deltaMs: now - startTime,
+                        source: 'stdout',
+                        length: text.length,
+                        snippet: text.slice(0, 50).replace(/\n/g, '\\n')
+                    });
+                }
                 // Immediate check for obvious prompts
                 if (quickPromptPatterns.test(text)) {
                     session.isBlocked = true;
+                    exitReason = 'early_exit_quick_pattern';
+                    if (collectTiming && outputEvents.length > 0) {
+                        outputEvents[outputEvents.length - 1].matchedPattern = 'quick_pattern';
+                    }
                     resolveOnce({
                         pid: childProcess.pid,
                         output,
@@ -110,8 +148,22 @@ export class TerminalManager {
             });
             childProcess.stderr.on('data', (data) => {
                 const text = data.toString();
+                const now = Date.now();
+                if (!firstOutputTime)
+                    firstOutputTime = now;
+                lastOutputTime = now;
                 output += text;
                 session.lastOutput += text;
+                // Record output event if collecting timing
+                if (collectTiming) {
+                    outputEvents.push({
+                        timestamp: now,
+                        deltaMs: now - startTime,
+                        source: 'stderr',
+                        length: text.length,
+                        snippet: text.slice(0, 50).replace(/\n/g, '\\n')
+                    });
+                }
             });
             // Periodic comprehensive check every 100ms
             periodicCheck = setInterval(() => {
@@ -119,6 +171,7 @@ export class TerminalManager {
                     const processState = analyzeProcessState(output, childProcess.pid);
                     if (processState.isWaitingForInput) {
                         session.isBlocked = true;
+                        exitReason = 'early_exit_periodic_check';
                         resolveOnce({
                             pid: childProcess.pid,
                             output,
@@ -130,6 +183,7 @@ export class TerminalManager {
             // Timeout fallback
             setTimeout(() => {
                 session.isBlocked = true;
+                exitReason = 'timeout';
                 resolveOnce({
                     pid: childProcess.pid,
                     output,
@@ -153,6 +207,7 @@ export class TerminalManager {
                     }
                     this.sessions.delete(childProcess.pid);
                 }
+                exitReason = 'process_exit';
                 resolveOnce({
                     pid: childProcess.pid,
                     output,

package/dist/tools/config.js

@@ -2,6 +2,7 @@ import { configManager } from '../config-manager.js';
 import { SetConfigValueArgsSchema } from './schemas.js';
 import { getSystemInfo } from '../utils/system-info.js';
 import { currentClient } from '../server.js';
+import { featureFlagManager } from '../utils/feature-flags.js';
 /**
  * Get the entire config including system information
  */
@@ -11,10 +12,23 @@ 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
+            featureFlags: featureFlagManager.getAll(),
+            systemInfo: {
+                ...systemInfo,
+                memory
+            }
         };
         console.error(`getConfig result: ${JSON.stringify(configWithSystemInfo, null, 2)}`);
         return {

package/dist/tools/feedback.js

@@ -73,7 +73,7 @@ export async function giveFeedbackToDesktopCommander(params = {}) {
             content: [{
                     type: "text",
                     text: `❌ **Error opening feedback form**: ${error instanceof Error ? error.message : String(error)}\n\n` +
-                        `You can still access our feedback form directly at: https://tally.so/r/mYB6av\n\n` +
+                        `You can still access our feedback form directly at: https://tally.so/r/mKqoKg\n\n` +
                         `We appreciate your willingness to provide feedback!`
                 }],
             isError: true
@@ -84,7 +84,7 @@ export async function giveFeedbackToDesktopCommander(params = {}) {
  * Build Tally.so URL with pre-filled parameters
  */
 async function buildTallyUrl(params, stats) {
-    const baseUrl = 'https://tally.so/r/mYB6av';
+    const baseUrl = 'https://tally.so/r/mKqoKg';
     const urlParams = new URLSearchParams();
     // Only auto-filled hidden fields remain
     urlParams.set('tool_call_count', stats.totalToolCalls.toString());

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>>;

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);