@wonderwhy-er/desktop-commander 0.2.14 → 0.2.15

package/README.md

@@ -86,6 +86,11 @@ For debugging mode (allows Node.js inspector connection):
 ```
 npx @wonderwhy-er/desktop-commander@latest setup --debug
 ```
+
+**Command line options during setup:**
+- `--debug`: Enable debugging mode for Node.js inspector
+- `--no-onboarding`: Disable onboarding prompts for new users
+
 Restart Claude if running.
 
 **✅ Auto-Updates:** Yes - automatically updates when you restart Claude  
@@ -652,6 +657,44 @@ set_config_value({ "key": "fileWriteLineLimit", "value": 25 })
 
 4. **Always verify configuration after changes**: Use `get_config({})` to confirm your changes were applied correctly.
 
+## Command Line Options
+
+Desktop Commander supports several command line options for customizing behavior:
+
+### Disable Onboarding
+
+By default, Desktop Commander shows helpful onboarding prompts to new users (those with fewer than 10 tool calls). You can disable this behavior:
+
+```bash
+# Disable onboarding for this session
+node dist/index.js --no-onboarding
+
+# Or if using npm scripts
+npm run start:no-onboarding
+
+# For npx installations, modify your claude_desktop_config.json:
+{
+  "mcpServers": {
+    "desktop-commander": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@wonderwhy-er/desktop-commander@latest",
+        "--no-onboarding"
+      ]
+    }
+  }
+}
+```
+
+**When onboarding is automatically disabled:**
+- When the MCP client name is set to "desktop-commander"
+- When using the `--no-onboarding` flag
+- After users have used onboarding prompts or made 10+ tool calls
+
+**Debug information:**
+The server will log when onboarding is disabled: `"Onboarding disabled via --no-onboarding flag"`
+
 ## Using Different Shells
 
 You can specify which shell to use for command execution:

package/dist/custom-stdio.js

@@ -22,14 +22,16 @@ export class FilteredStdioServerTransport extends StdioServerTransport {
         this.setupConsoleRedirection();
         // Setup stdout filtering for any other output
         this.setupStdoutFiltering();
-        // Send initialization notification
-        this.sendLogNotification('info', ['Enhanced FilteredStdioServerTransport initialized']);
+        // Note: We defer the initialization notification until enableNotifications() is called
+        // to ensure MCP protocol compliance - notifications must not be sent before initialization
     }
     /**
      * Call this method after MCP initialization is complete to enable JSON-RPC notifications
      */
     enableNotifications() {
         this.isInitialized = true;
+        // Send the deferred initialization notification first
+        this.sendLogNotification('info', ['Enhanced FilteredStdioServerTransport initialized']);
         // Replay all buffered messages in chronological order
         if (this.messageBuffer.length > 0) {
             this.sendLogNotification('info', [`Replaying ${this.messageBuffer.length} buffered initialization messages`]);

package/dist/index.js

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 import { FilteredStdioServerTransport } from './custom-stdio.js';
-import { server } from './server.js';
+import { server, flushDeferredMessages } from './server.js';
 import { configManager } from './config-manager.js';
 import { runSetup } from './npm-scripts/setup.js';
 import { runUninstall } from './npm-scripts/uninstall.js';
 import { capture } from './utils/capture.js';
 import { logToStderr, logger } from './utils/logger.js';
+// Store messages to defer until after initialization
+const deferredMessages = [];
+function deferLog(level, message) {
+    deferredMessages.push({ level, message });
+}
 async function runServer() {
     try {
         // Check if first argument is "setup"
@@ -18,17 +23,24 @@ async function runServer() {
             await runUninstall();
             return;
         }
+        // Parse command line arguments for onboarding control
+        const DISABLE_ONBOARDING = process.argv.includes('--no-onboarding');
+        if (DISABLE_ONBOARDING) {
+            logToStderr('info', 'Onboarding disabled via --no-onboarding flag');
+        }
+        // Set global flag for onboarding control
+        global.disableOnboarding = DISABLE_ONBOARDING;
         try {
-            logToStderr('info', 'Loading configuration...');
+            deferLog('info', 'Loading configuration...');
             await configManager.loadConfig();
-            logToStderr('info', 'Configuration loaded successfully');
+            deferLog('info', 'Configuration loaded successfully');
         }
         catch (configError) {
-            logToStderr('error', `Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            deferLog('error', `Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
             if (configError instanceof Error && configError.stack) {
-                logToStderr('debug', `Stack trace: ${configError.stack}`);
+                deferLog('debug', `Stack trace: ${configError.stack}`);
             }
-            logToStderr('warning', 'Continuing with in-memory configuration only');
+            deferLog('warning', 'Continuing with in-memory configuration only');
             // Continue anyway - we'll use an in-memory config
         }
         const transport = new FilteredStdioServerTransport();
@@ -63,17 +75,23 @@ async function runServer() {
             process.exit(1);
         });
         capture('run_server_start');
-        logToStderr('info', 'Connecting server...');
+        deferLog('info', 'Connecting server...');
         // Set up event-driven initialization completion handler
         server.oninitialized = () => {
             // This callback is triggered after the client sends the "initialized" notification
             // At this point, the MCP protocol handshake is fully complete
             transport.enableNotifications();
-            // Use the transport to send a proper JSON-RPC notification
-            transport.sendLog('info', 'MCP fully initialized, notifications enabled');
+            // Flush all deferred messages from both index.ts and server.ts
+            while (deferredMessages.length > 0) {
+                const msg = deferredMessages.shift();
+                transport.sendLog('info', msg.message);
+            }
+            flushDeferredMessages();
+            // Now we can send regular logging messages
+            transport.sendLog('info', 'Server connected successfully');
+            transport.sendLog('info', 'MCP fully initialized, all startup messages sent');
         };
         await server.connect(transport);
-        logToStderr('info', 'Server connected successfully');
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function flushDeferredMessages(): void;
 export declare const server: Server<{
     method: string;
     params?: {

package/dist/server.js

@@ -18,8 +18,20 @@ import { usageTracker } from './utils/usageTracker.js';
 import { processDockerPrompt } from './utils/dockerPrompt.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
-import { logToStderr } from './utils/logger.js';
-logToStderr('info', 'Loading server.ts');
+import { logToStderr, logger } from './utils/logger.js';
+// Store startup messages to send after initialization
+const deferredMessages = [];
+function deferLog(level, message) {
+    deferredMessages.push({ level, message });
+}
+// Function to flush deferred messages after initialization
+export function flushDeferredMessages() {
+    while (deferredMessages.length > 0) {
+        const msg = deferredMessages.shift();
+        logger.info(msg.message);
+    }
+}
+deferLog('info', 'Loading server.ts');
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -57,8 +69,8 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
                 name: clientInfo.name || 'unknown',
                 version: clientInfo.version || 'unknown'
             };
-            // Send JSON-RPC notification about client connection
-            logToStderr('info', `Client connected: ${currentClient.name} v${currentClient.version}`);
+            // Defer client connection message until after initialization
+            deferLog('info', `Client connected: ${currentClient.name} v${currentClient.version}`);
         }
         // Return standard initialization response
         return {
@@ -82,7 +94,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
 });
 // Export current client info for access by other modules
 export { currentClient };
-logToStderr('info', 'Setting up request handlers...');
+deferLog('info', 'Setting up request handlers...');
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
         logToStderr('debug', 'Generating tools list...');

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import { ChildProcess } from 'child_process';
 import { FilteredStdioServerTransport } from './custom-stdio.js';
 declare global {
     var mcpTransport: FilteredStdioServerTransport | undefined;
+    var disableOnboarding: boolean | undefined;
 }
 export interface ProcessInfo {
     pid: number;

package/dist/utils/usageTracker.js

@@ -299,6 +299,21 @@ class UsageTracker {
      * Check if user should see onboarding invitation - SIMPLE VERSION
      */
     async shouldShowOnboarding() {
+        // Check if onboarding is disabled via command line argument
+        if (global.disableOnboarding) {
+            return false;
+        }
+        // Check if client is desktop-commander (disable for this client)
+        try {
+            const { currentClient } = await import('../server.js');
+            if (currentClient?.name === 'desktop-commander') {
+                return false;
+            }
+        }
+        catch (error) {
+            // If we can't import server, continue with other checks
+            console.log('[ONBOARDING DEBUG] Could not check client name, continuing...');
+        }
         const stats = await this.getStats();
         const onboardingState = await this.getOnboardingState();
         const now = Date.now();

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",