@wonderwhy-er/desktop-commander 0.1.34 → 0.1.35

package/dist/setup-claude-server.js

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

package/dist/terminal-manager.d.ts

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

package/dist/terminal-manager.js

@@ -1,12 +1,29 @@
 import { spawn } from 'child_process';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
+import { configManager } from './config-manager.js';
+import { capture } from "./utils.js";
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.completedSessions = new Map();
     }
-    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
-        const process = spawn(command, [], { shell: true });
+    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell) {
+        // Get the shell from config if not specified
+        let shellToUse = shell;
+        if (!shellToUse) {
+            try {
+                const config = await configManager.getConfig();
+                shellToUse = config.shell || true;
+            }
+            catch (error) {
+                // If there's an error getting the config, fall back to default
+                shellToUse = true;
+            }
+        }
+        const spawnOptions = {
+            shell: shellToUse
+        };
+        const process = spawn(command, [], spawnOptions);
         let output = '';
         // Ensure process.pid is defined before proceeding
         if (!process.pid) {
@@ -101,7 +118,7 @@ export class TerminalManager {
             return true;
         }
         catch (error) {
-            console.error(`Failed to terminate process ${pid}:`, error);
+            capture('server_request_error', { error: error, message: `Failed to terminate process ${pid}:` });
             return false;
         }
     }

package/dist/tools/config.d.ts

@@ -1,29 +1,3 @@
-import { z } from 'zod';
-export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const GetConfigValueArgsSchema: z.ZodObject<{
-    key: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-}, {
-    key: string;
-}>;
-export declare const SetConfigValueArgsSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    value?: any;
-}, {
-    key: string;
-    value?: any;
-}>;
-export declare const UpdateConfigArgsSchema: z.ZodObject<{
-    config: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    config: Record<string, any>;
-}, {
-    config: Record<string, any>;
-}>;
 /**
  * Get the entire config
  */
@@ -33,22 +7,6 @@ export declare function getConfig(): Promise<{
         text: string;
     }[];
 }>;
-/**
- * Get a specific config value
- */
-export declare function getConfigValue(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;
 /**
  * Set a specific config value
  */
@@ -65,19 +23,3 @@ export declare function setConfigValue(args: unknown): Promise<{
     }[];
     isError?: undefined;
 }>;
-/**
- * Update multiple config values at once
- */
-export declare function updateConfig(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;

package/dist/tools/config.js

@@ -1,17 +1,5 @@
-import { z } from 'zod';
 import { configManager } from '../config-manager.js';
-// Schemas for config operations
-export const GetConfigArgsSchema = z.object({});
-export const GetConfigValueArgsSchema = z.object({
-    key: z.string(),
-});
-export const SetConfigValueArgsSchema = z.object({
-    key: z.string(),
-    value: z.any(),
-});
-export const UpdateConfigArgsSchema = z.object({
-    config: z.record(z.any()),
-});
+import { SetConfigValueArgsSchema } from './schemas.js';
 /**
  * Get the entire config
  */
@@ -39,46 +27,6 @@ export async function getConfig() {
         };
     }
 }
-/**
- * Get a specific config value
- */
-export async function getConfigValue(args) {
-    console.error(`getConfigValue called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = GetConfigValueArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for get_config_value: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        const value = await configManager.getValue(parsed.data.key);
-        console.error(`getConfigValue result for key ${parsed.data.key}: ${JSON.stringify(value)}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: value !== undefined
-                        ? `Value for ${parsed.data.key}: ${JSON.stringify(value, null, 2)}`
-                        : `No value found for key: ${parsed.data.key}`
-                }],
-        };
-    }
-    catch (error) {
-        console.error(`Error in getConfigValue: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error retrieving value: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}
 /**
  * Set a specific config value
  */
@@ -97,12 +45,52 @@ export async function setConfigValue(args) {
             };
         }
         try {
-            await configManager.setValue(parsed.data.key, parsed.data.value);
-            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value)}`);
+            // Parse string values that should be arrays or objects
+            let valueToStore = parsed.data.value;
+            // If the value is a string that looks like an array or object, try to parse it
+            if (typeof valueToStore === 'string' &&
+                (valueToStore.startsWith('[') || valueToStore.startsWith('{'))) {
+                try {
+                    valueToStore = JSON.parse(valueToStore);
+                    console.error(`Parsed string value to object/array: ${JSON.stringify(valueToStore)}`);
+                }
+                catch (parseError) {
+                    console.error(`Failed to parse string as JSON, using as-is: ${parseError}`);
+                }
+            }
+            // Special handling for known array configuration keys
+            if ((parsed.data.key === 'allowedDirectories' || parsed.data.key === 'blockedCommands') &&
+                !Array.isArray(valueToStore)) {
+                if (typeof valueToStore === 'string') {
+                    try {
+                        valueToStore = JSON.parse(valueToStore);
+                    }
+                    catch (parseError) {
+                        console.error(`Failed to parse string as array for ${parsed.data.key}: ${parseError}`);
+                        // If parsing failed and it's a single value, convert to an array with one item
+                        if (!valueToStore.includes('[')) {
+                            valueToStore = [valueToStore];
+                        }
+                    }
+                }
+                else {
+                    // If not a string or array, convert to an array with one item
+                    valueToStore = [valueToStore];
+                }
+                // Ensure the value is an array after all our conversions
+                if (!Array.isArray(valueToStore)) {
+                    console.error(`Value for ${parsed.data.key} is still not an array, converting to array`);
+                    valueToStore = [String(valueToStore)];
+                }
+            }
+            await configManager.setValue(parsed.data.key, valueToStore);
+            // Get the updated configuration to show the user
+            const updatedConfig = await configManager.getConfig();
+            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore)}`);
             return {
                 content: [{
                         type: "text",
-                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value, null, 2)}`
+                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore, null, 2)}\n\nUpdated configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
                     }],
             };
         }
@@ -130,54 +118,3 @@ export async function setConfigValue(args) {
         };
     }
 }
-/**
- * Update multiple config values at once
- */
-export async function updateConfig(args) {
-    console.error(`updateConfig called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = UpdateConfigArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for update_config: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        try {
-            const updatedConfig = await configManager.updateConfig(parsed.data.config);
-            console.error(`updateConfig result: ${JSON.stringify(updatedConfig, null, 2)}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated successfully.\nNew configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
-                    }],
-            };
-        }
-        catch (saveError) {
-            console.error(`Error saving updated config: ${saveError.message}`);
-            // Return useful response instead of crashing
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated in memory but couldn't be saved to disk: ${saveError.message}`
-                    }],
-                isError: true
-            };
-        }
-    }
-    catch (error) {
-        console.error(`Error in updateConfig: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error updating configuration: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}

package/dist/tools/debug-path.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/debug-path.js

@@ -0,0 +1,44 @@
+// This is a debug script to help understand how ~ expansion works
+import os from 'os';
+import path from 'path';
+function expandHome(filepath) {
+    console.log(`Expanding ${filepath}`);
+    // Handle both '~' alone or '~/' path prefix
+    if (filepath === '~') {
+        const home = os.homedir();
+        console.log(`~ expanded to ${home}`);
+        return home;
+    }
+    else if (filepath.startsWith('~/')) {
+        const joinedPath = path.join(os.homedir(), filepath.slice(2));
+        console.log(`~/ expanded to ${joinedPath}`);
+        return joinedPath;
+    }
+    return filepath;
+}
+console.log(`Home directory: ${os.homedir()}`);
+console.log(`Current working directory: ${process.cwd()}`);
+console.log(`Expanding ~: ${expandHome('~')}`);
+console.log(`Expanding ~/Documents: ${expandHome('~/Documents')}`);
+console.log(`Expanding /tmp: ${expandHome('/tmp')}`);
+// Create lowercase normalized paths for comparison
+function normalizePath(p) {
+    return path.normalize(p).toLowerCase();
+}
+const allowedDir = '~';
+const expandedAllowedDir = expandHome(allowedDir);
+const normalizedAllowedDir = normalizePath(expandedAllowedDir);
+console.log(`Allowed dir: ${allowedDir}`);
+console.log(`Expanded allowed dir: ${expandedAllowedDir}`);
+console.log(`Normalized allowed dir: ${normalizedAllowedDir}`);
+// Example path to check
+const pathToCheck = '~';
+const expandedPathToCheck = expandHome(pathToCheck);
+const normalizedPathToCheck = normalizePath(expandedPathToCheck);
+console.log(`Path to check: ${pathToCheck}`);
+console.log(`Expanded path to check: ${expandedPathToCheck}`);
+console.log(`Normalized path to check: ${normalizedPathToCheck}`);
+// Check if path is allowed
+const isAllowed = normalizedPathToCheck === normalizedAllowedDir ||
+    normalizedPathToCheck.startsWith(normalizedAllowedDir + path.sep);
+console.log(`Is path allowed: ${isAllowed}`);

package/dist/tools/edit.js

@@ -1,20 +1,23 @@
 import { readFile, writeFile } from './filesystem.js';
 export async function performSearchReplace(filePath, block) {
     // Read file as plain string (don't pass true to get just the string)
-    const content = await readFile(filePath);
+    const { content } = await readFile(filePath);
     // Make sure content is a string
-    const contentStr = typeof content === 'string' ? content : content.content;
+    if (typeof content !== 'string') {
+        throw new Error('Wrong content for file ' + filePath);
+    }
+    ;
     // Find first occurrence
-    const searchIndex = contentStr.indexOf(block.search);
+    const searchIndex = content.indexOf(block.search);
     if (searchIndex === -1) {
         return {
             content: [{ type: "text", text: `Search content not found in ${filePath}.` }],
         };
     }
     // Replace content
-    const newContent = contentStr.substring(0, searchIndex) +
+    const newContent = content.substring(0, searchIndex) +
         block.replace +
-        contentStr.substring(searchIndex + block.search.length);
+        content.substring(searchIndex + block.search.length);
     await writeFile(filePath, newContent);
     return {
         content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],

package/dist/tools/execute.js

@@ -24,16 +24,16 @@ export async function executeCommand(args) {
         capture('server_execute_command', {
             command: commandManager.getBaseCommand(parsed.data.command)
         });
-        // Log the error but continue execution
-        console.error('Error during command extraction:', error);
     }
-    if (!commandManager.validateCommand(parsed.data.command)) {
+    // Command validation is now async
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
         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);
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, parsed.data.shell);
     // Check for error condition (pid = -1)
     if (result.pid === -1) {
         return {

package/dist/tools/filesystem-fixed.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read a file from either the local filesystem or a URL
+ * @param filePath Path to the file or URL
+ * @param returnMetadata Whether to return metadata with the content
+ * @param isUrl Whether the path is a URL
+ * @returns File content or file result with metadata
+ */
+export declare function readFile(filePath: string, returnMetadata?: boolean, isUrl?: boolean): Promise<string | FileResult>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export interface MultiFileResult {
+    path: string;
+    content?: string;
+    mimeType?: string;
+    isImage?: boolean;
+    error?: string;
+}
+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 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>>;