@wonderwhy-er/desktop-commander 0.2.35 → 0.2.37

package/README.md

@@ -2,6 +2,7 @@
 ### Search, update, manage files and run terminal commands with AI
 
 [![npm downloads](https://img.shields.io/npm/dw/@wonderwhy-er/desktop-commander)](https://www.npmjs.com/package/@wonderwhy-er/desktop-commander)
+[![AgentAudit Verified](https://agentaudit.dev/api/badge/desktop-commander)](https://agentaudit.dev/skills/desktop-commander)
 [![Trust Score](https://archestra.ai/mcp-catalog/api/badge/quality/wonderwhy-er/DesktopCommanderMCP)](https://archestra.ai/mcp-catalog/wonderwhy-er__desktopcommandermcp)
 [![smithery badge](https://smithery.ai/badge/@wonderwhy-er/desktop-commander)](https://smithery.ai/server/@wonderwhy-er/desktop-commander)
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow.svg)](https://www.buymeacoffee.com/wonderwhyer)
@@ -16,6 +17,8 @@ Work with code and text, run processes, and automate tasks, going far beyond oth
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Desktop Commander MCP" />
 </a>
 
+## 👋 We’re hiring — come build with us: https://desktopcommander.app/careers/
+
 ## Table of Contents
 - [Features](#features)
 - [How to install](#how-to-install)

package/dist/handlers/filesystem-handlers.js

@@ -3,11 +3,34 @@ import { withTimeout } from '../utils/withTimeout.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { configManager } from '../config-manager.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, WritePdfArgsSchema } from '../tools/schemas.js';
+import path from 'path';
+import os from 'os';
+import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from '../ui/contracts.js';
+import { resolvePreviewFileType } from '../ui/file-preview/shared/preview-file-types.js';
+/**
+ * Expand home directory (~) in a file path
+ */
+function expandHome(filePath) {
+    if (filePath === '~' || filePath.startsWith('~/') || filePath.startsWith(`~${path.sep}`)) {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+/**
+ * Resolve a file path to an absolute path for use in structured content.
+ * This ensures "Open in folder" always has a valid absolute path.
+ */
+function resolveAbsolutePath(filePath) {
+    const expanded = expandHome(filePath);
+    return path.isAbsolute(expanded)
+        ? path.resolve(expanded)
+        : path.resolve(process.cwd(), expanded);
+}
 /**
  * Helper function to check if path contains an error
  */
-function isErrorPath(path) {
-    return path.startsWith('__ERROR__:');
+function isErrorPath(filePath) {
+    return filePath.startsWith('__ERROR__:');
 }
 /**
  * Extract error message from error path
@@ -44,6 +67,10 @@ export async function handleReadFile(args) {
             sheet: sheetParam,
             range: parsed.range
         };
+        // Resolve to absolute path for local files (not URLs) so "Open in folder" works
+        const resolvedFilePath = parsed.isUrl
+            ? parsed.path
+            : resolveAbsolutePath(parsed.path);
         const fileResult = await readFile(parsed.path, options);
         // Handle PDF files
         if (fileResult.metadata?.isPdf) {
@@ -68,28 +95,40 @@ export async function handleReadFile(args) {
                         text: `PDF file: ${parsed.path}${author}${title} (${meta?.totalPages} pages) \n`
                     },
                     ...pdfContent
-                ]
+                ],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: 'unsupported',
+                    content: ''
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         // Handle image files
         if (fileResult.metadata?.isImage) {
-            // For image files, return as an image content type
-            // Content should already be base64-encoded string from handler
+            // For image files, keep content payload text-only for broad host compatibility.
+            // The preview widget reads image bytes from structuredContent.
             const imageData = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('base64');
+            const imageSummary = `Image file: ${parsed.path} (${fileResult.mimeType})\n`;
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Image file: ${parsed.path} (${fileResult.mimeType})\n`
-                    },
-                    {
-                        type: "image",
-                        data: imageData,
-                        mimeType: fileResult.mimeType
+                        text: imageSummary
                     }
                 ],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: 'image',
+                    content: imageSummary,
+                    imageData,
+                    mimeType: fileResult.mimeType
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         else {
@@ -97,8 +136,16 @@ export async function handleReadFile(args) {
             const textContent = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('utf8');
+            const previewFileType = resolvePreviewFileType(resolvedFilePath);
             return {
                 content: [{ type: "text", text: textContent }],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: previewFileType,
+                    content: textContent
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
     };

package/dist/handlers/history-handlers.d.ts

@@ -1,5 +1,12 @@
 import { ServerResult } from '../types.js';
+type TrackUiEventParams = Record<string, string | number | boolean | null>;
+export declare function buildTrackUiEventCapturePayload(event: string, component: string, params: TrackUiEventParams): Record<string, string | number | boolean | null>;
 /**
  * Handle get_recent_tool_calls command
  */
 export declare function handleGetRecentToolCalls(args: unknown): Promise<ServerResult>;
+/**
+ * Handle track_ui_event command
+ */
+export declare function handleTrackUiEvent(args: unknown): Promise<ServerResult>;
+export {};

package/dist/handlers/history-handlers.js

@@ -1,5 +1,13 @@
 import { toolHistory } from '../utils/toolHistory.js';
-import { GetRecentToolCallsArgsSchema } from '../tools/schemas.js';
+import { GetRecentToolCallsArgsSchema, TrackUiEventArgsSchema } from '../tools/schemas.js';
+import { capture_ui_event } from '../utils/capture.js';
+export function buildTrackUiEventCapturePayload(event, component, params) {
+    return {
+        ...params,
+        component,
+        event
+    };
+}
 /**
  * Handle get_recent_tool_calls command
  */
@@ -33,3 +41,27 @@ export async function handleGetRecentToolCalls(args) {
         };
     }
 }
+/**
+ * Handle track_ui_event command
+ */
+export async function handleTrackUiEvent(args) {
+    try {
+        const parsed = TrackUiEventArgsSchema.parse(args);
+        await capture_ui_event('mcp_ui_event', buildTrackUiEventCapturePayload(parsed.event, parsed.component, parsed.params));
+        return {
+            content: [{
+                    type: "text",
+                    text: `Tracked UI event: ${parsed.event}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error tracking UI event: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/remote-device/remote-channel.d.ts

@@ -36,10 +36,15 @@ export declare class RemoteChannel {
         id: any;
         device_name: any;
     } | null>;
-    updateDevice(deviceId: string, updates: any): Promise<import("@supabase/postgrest-js").PostgrestSingleResponse<null>>;
-    createDevice(deviceData: DeviceData): Promise<import("@supabase/postgrest-js").PostgrestSingleResponse<any>>;
+    updateDevice(deviceId: string, updates: any): Promise<{
+        data: any[] | null;
+        error: import("@supabase/postgrest-js").PostgrestError | null;
+    }>;
+    createDevice(deviceData: DeviceData): Promise<{
+        data: any;
+        error: null;
+    }>;
     registerDevice(capabilities: any, currentDeviceId: string | undefined, deviceName: string, onToolCall: (payload: any) => void): Promise<void>;
-    subscribe(deviceId: string, onToolCall: (payload: any) => void): Promise<void>;
     /**
      * Create and subscribe to the channel.
      * This is used for both initial subscription and recreation after socket reconnects.

package/dist/remote-device/remote-channel.js

@@ -28,14 +28,26 @@ export class RemoteChannel {
             access_token: session.access_token,
             refresh_token: session.refresh_token || ''
         });
+        if (error) {
+            console.error('[DEBUG] Failed to set session:', error.message);
+            await captureRemote('remote_channel_set_session_error', { error });
+            return { error };
+        }
         // Get user info
         const { data: { user }, error: userError } = await this.client.auth.getUser();
         if (userError) {
-            console.debug('[DEBUG] Failed to get user:', userError.message);
+            console.error('[DEBUG] Failed to get user:', userError.message);
+            await captureRemote('remote_channel_get_user_error', { error: userError });
             throw userError;
         }
+        if (!user) {
+            const noUserError = new Error('No user returned after setSession');
+            console.error('[DEBUG] No user returned:', noUserError.message);
+            await captureRemote('remote_channel_get_user_empty', {});
+            throw noUserError;
+        }
         this._user = user;
-        console.debug('[DEBUG] Session set successfully, user:', user?.email);
+        console.debug('[DEBUG] Session set successfully, user:', user.email);
         return { error };
     }
     async getSession() {
@@ -52,26 +64,45 @@ export class RemoteChannel {
             .eq('id', deviceId)
             .eq('user_id', this.user?.id)
             .maybeSingle();
-        if (error)
+        if (error) {
+            console.error('[DEBUG] Failed to find device:', error.message);
+            await captureRemote('remote_channel_find_device_error', { error });
             throw error;
+        }
         return data;
     }
     async updateDevice(deviceId, updates) {
         if (!this.client)
             throw new Error('Client not initialized');
-        return await this.client
+        const { data, error } = await this.client
             .from('mcp_devices')
             .update(updates)
-            .eq('id', deviceId);
+            .eq('id', deviceId)
+            .select();
+        if (error) {
+            console.error('[DEBUG] Failed to update device:', error.message);
+            await captureRemote('remote_channel_update_device_error', { error });
+        }
+        else {
+            console.debug('[DEBUG] Device updated successfully');
+        }
+        return { data, error };
     }
     async createDevice(deviceData) {
         if (!this.client)
             throw new Error('Client not initialized');
-        return await this.client
+        const { data, error } = await this.client
             .from('mcp_devices')
             .insert(deviceData)
             .select()
             .single();
+        if (error) {
+            console.error('[DEBUG] Failed to create device:', error.message);
+            await captureRemote('remote_channel_create_device_error', { error });
+            throw error;
+        }
+        console.debug('[DEBUG] Device created successfully');
+        return { data, error };
     }
     async registerDevice(capabilities, currentDeviceId, deviceName, onToolCall) {
         console.debug('[DEBUG] RemoteChannel.registerDevice() called, deviceId:', currentDeviceId);
@@ -95,7 +126,10 @@ export class RemoteChannel {
             console.debug(`⏳ Subscribing to tool call channel...`);
             // Create and subscribe to the channel
             console.debug('[DEBUG] Calling createChannel()');
-            await this.createChannel();
+            // ! Ignore silently in Inialization to reconnect after
+            await this.createChannel().catch((error) => {
+                console.debug('[DEBUG] Failed to create channel, will retry after socket reconnect', error);
+            });
         }
         else {
             console.error(`   - ❌ Device not found: ${currentDeviceId}`);
@@ -103,16 +137,6 @@ export class RemoteChannel {
             throw new Error(`Device not found: ${currentDeviceId}`);
         }
     }
-    async subscribe(deviceId, onToolCall) {
-        if (!this.client)
-            throw new Error('Client not initialized');
-        // Store parameters for channel recreation
-        this.deviceId = deviceId;
-        this.onToolCall = onToolCall;
-        console.debug(`⏳ Subscribing to tool call channel...`);
-        // Create and subscribe to the channel
-        await this.createChannel();
-    }
     /**
      * Create and subscribe to the channel.
      * This is used for both initial subscription and recreation after socket reconnects.
@@ -156,7 +180,7 @@ export class RemoteChannel {
                     reject(err || new Error('Failed to initialize tool call channel subscription'));
                 }
                 else if (status === 'TIMED_OUT') {
-                    console.error('⏱️ Channel subscription timed out');
+                    console.error('⏱️ Channel subscription timed out, Reconnecting...');
                     this.setOnlineStatus(this.deviceId, 'offline');
                     captureRemote('remote_channel_subscription_timeout', {}).catch(() => { });
                     reject(new Error('Tool call channel subscription timed out'));
@@ -213,10 +237,17 @@ export class RemoteChannel {
     async markCallExecuting(callId) {
         if (!this.client)
             throw new Error('Client not initialized');
-        await this.client
+        const { error } = await this.client
             .from('mcp_remote_calls')
             .update({ status: 'executing' })
             .eq('id', callId);
+        if (error) {
+            console.error('[DEBUG] Failed to mark call executing:', error.message);
+            await captureRemote('remote_channel_mark_call_executing_error', { error });
+        }
+        else {
+            console.debug('[DEBUG] Call marked executing:', callId);
+        }
     }
     async updateCallResult(callId, status, result = null, errorMessage = null) {
         if (!this.client)
@@ -229,19 +260,31 @@ export class RemoteChannel {
             updateData.result = result;
         if (errorMessage !== null)
             updateData.error_message = errorMessage;
-        await this.client
+        console.debug('[DEBUG] Updating call result:', updateData);
+        const { data, error } = await this.client
             .from('mcp_remote_calls')
             .update(updateData)
             .eq('id', callId);
+        if (error) {
+            console.error('[DEBUG] Failed to update call result:', error.message);
+            await captureRemote('remote_channel_update_call_result_error', { error });
+        }
+        else {
+            console.debug('[DEBUG] Call result updated successfully:', data);
+        }
     }
     async updateHeartbeat(deviceId) {
         if (!this.client)
             return;
         try {
-            await this.client
+            const { error } = await this.client
                 .from('mcp_devices')
                 .update({ last_seen: new Date().toISOString() })
                 .eq('id', deviceId);
+            if (error) {
+                console.error('[DEBUG] Heartbeat update failed:', error.message);
+                await captureRemote('remote_channel_heartbeat_error', { error });
+            }
             // console.log(`🔌 Heartbeat sent for device: ${deviceId}`);
         }
         catch (error) {
@@ -283,12 +326,16 @@ export class RemoteChannel {
             .update({ status: status, last_seen: new Date().toISOString() })
             .eq('id', deviceId);
         if (error) {
+            console.error(`[DEBUG] Failed to set status ${status}:`, error.message);
             if (status == "online") {
                 console.error('Failed to update device status:', error.message);
             }
             await captureRemote('remote_channel_status_update_error', { error, status });
             return;
         }
+        else {
+            console.debug(`[DEBUG] Device status set to ${status}`);
+        }
         // console.log(status === 'online' ? `🔌 Device marked as ${status}` : `❌ Device marked as ${status}`);
     }
     async setOffline(deviceId) {

package/dist/search-manager.d.ts

@@ -97,6 +97,19 @@ export interface SearchSessionOptions {
      * Find all Excel files in a directory recursively
      */
     private findExcelFiles;
+    /**
+     * Determine if DOCX search should be included based on context
+     */
+    private shouldIncludeDocxSearch;
+    /**
+     * Search DOCX files for content matches
+     * Extracts <w:t> text from document.xml and searches it
+     */
+    private searchDocxFiles;
+    /**
+     * Find all DOCX files in a directory recursively
+     */
+    private findDocxFiles;
     /**
      * Extract context around a match for display (show surrounding text)
      */

package/dist/search-manager.js

@@ -5,6 +5,7 @@ import { validatePath } from './tools/filesystem.js';
 import { capture } from './utils/capture.js';
 import { getRipgrepPath } from './utils/ripgrep-resolver.js';
 import { isExcelFile } from './utils/files/index.js';
+import PizZip from 'pizzip';
 /**
  * Search Session Manager - handles ripgrep processes like terminal sessions
  * Supports both file search and content search with progressive results
@@ -105,6 +106,19 @@ import { isExcelFile } from './utils/files/index.js';
                 capture('excel_search_error', { error: err instanceof Error ? err.message : String(err) });
             });
         }
+        // For content searches, also search DOCX files
+        const shouldSearchDocx = options.searchType === 'content' &&
+            this.shouldIncludeDocxSearch(options.filePattern, validPath);
+        if (shouldSearchDocx) {
+            this.searchDocxFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern).then(docxResults => {
+                for (const result of docxResults) {
+                    session.results.push(result);
+                    session.totalMatches++;
+                }
+            }).catch((err) => {
+                capture('docx_search_error', { error: err instanceof Error ? err.message : String(err) });
+            });
+        }
         // Wait for first chunk of data or early completion instead of fixed delay
         // Excel search runs in background and results are merged via readSearchResults
         const firstChunk = new Promise(resolve => {
@@ -349,6 +363,138 @@ import { isExcelFile } from './utils/files/index.js';
         }
         return excelFiles;
     }
+    /**
+     * Determine if DOCX search should be included based on context
+     */
+    shouldIncludeDocxSearch(filePattern, rootPath) {
+        const docxExtensions = ['.docx'];
+        if (rootPath) {
+            const lowerPath = rootPath.toLowerCase();
+            if (docxExtensions.some(ext => lowerPath.endsWith(ext))) {
+                return true;
+            }
+        }
+        if (filePattern) {
+            const lowerPattern = filePattern.toLowerCase();
+            if (docxExtensions.some(ext => lowerPattern.includes(`*${ext}`) || lowerPattern.endsWith(ext))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Search DOCX files for content matches
+     * Extracts <w:t> text from document.xml and searches it
+     */
+    async searchDocxFiles(rootPath, pattern, ignoreCase, maxResults, filePattern) {
+        const results = [];
+        const flags = ignoreCase ? 'i' : '';
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags);
+        }
+        catch {
+            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            regex = new RegExp(escaped, flags);
+        }
+        let docxFiles = await this.findDocxFiles(rootPath);
+        if (filePattern) {
+            const patterns = filePattern.split('|').map(p => p.trim()).filter(Boolean);
+            docxFiles = docxFiles.filter(filePath => {
+                const fileName = path.basename(filePath);
+                return patterns.some(pat => {
+                    if (pat.includes('*')) {
+                        const regexPat = pat.replace(/\./g, '\\.').replace(/\*/g, '.*');
+                        return new RegExp(`^${regexPat}$`, 'i').test(fileName);
+                    }
+                    return fileName.toLowerCase() === pat.toLowerCase();
+                });
+            });
+        }
+        for (const filePath of docxFiles) {
+            if (maxResults && results.length >= maxResults)
+                break;
+            try {
+                const buf = await fs.readFile(filePath);
+                const zip = new PizZip(buf);
+                // Search all XML parts that can contain text
+                const xmlParts = ['word/document.xml', 'word/header1.xml', 'word/header2.xml',
+                    'word/header3.xml', 'word/footer1.xml', 'word/footer2.xml', 'word/footer3.xml'];
+                for (const xmlPath of xmlParts) {
+                    if (maxResults && results.length >= maxResults)
+                        break;
+                    const file = zip.file(xmlPath);
+                    if (!file)
+                        continue;
+                    const xml = file.asText();
+                    // Extract all <w:t> text with position tracking
+                    const wtRe = /<w:t(?:\s[^>]*)?>([^<]*)<\/w:t>/g;
+                    let m;
+                    let lineNum = 0;
+                    while ((m = wtRe.exec(xml)) !== null) {
+                        if (maxResults && results.length >= maxResults)
+                            break;
+                        const text = m[1];
+                        if (!text || !text.trim())
+                            continue;
+                        lineNum++;
+                        if (regex.test(text)) {
+                            const match = text.match(regex);
+                            const matchContext = match
+                                ? this.getMatchContext(text, match.index || 0, match[0].length)
+                                : text.substring(0, 150);
+                            const partName = xmlPath === 'word/document.xml' ? '' : `:${xmlPath.replace('word/', '')}`;
+                            results.push({
+                                file: `${filePath}${partName}`,
+                                line: lineNum,
+                                match: matchContext,
+                                type: 'content'
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return results;
+    }
+    /**
+     * Find all DOCX files in a directory recursively
+     */
+    async findDocxFiles(rootPath) {
+        const docxFiles = [];
+        const isDocx = (name) => name.toLowerCase().endsWith('.docx');
+        async function walk(dir) {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                            await walk(fullPath);
+                        }
+                    }
+                    else if (entry.isFile() && isDocx(entry.name)) {
+                        docxFiles.push(fullPath);
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+        try {
+            const stats = await fs.stat(rootPath);
+            if (stats.isFile() && isDocx(rootPath)) {
+                return [rootPath];
+            }
+            else if (stats.isDirectory()) {
+                await walk(rootPath);
+            }
+        }
+        catch { /* skip */ }
+        return docxFiles;
+    }
     /**
      * Extract context around a match for display (show surrounding text)
      */