@wonderwhy-er/desktop-commander 0.2.39 → 0.2.41

package/dist/ui/file-preview/src/model.d.ts

@@ -1,6 +1,6 @@
 import type { DocumentOutlineItem } from './document-outline.js';
 import type { FilePreviewStructuredContent } from '../../../types.js';
-import type { MarkdownEditorView } from './markdown/editor.js';
+import type { MarkdownEditRange, MarkdownEditorView } from './markdown/editor.js';
 export type RenderPayload = FilePreviewStructuredContent & {
     content: string;
 };
@@ -12,6 +12,7 @@ export interface MarkdownWorkspaceState {
     outline: DocumentOutlineItem[];
     mode: 'edit';
     dirty: boolean;
+    dirtyLineRanges: MarkdownEditRange[];
     activeHeadingId: string | null;
     pendingAnchor: string | null;
     notice: string | null;

package/dist/ui/file-preview/src/payload-utils.js

@@ -41,6 +41,12 @@ export function extractToolText(value) {
     }
     return undefined;
 }
+function extractStructuredContentText(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    return typeof value.content === 'string' ? value.content : undefined;
+}
 export function extractRenderPayload(value) {
     if (!isObjectRecord(value)) {
         return undefined;
@@ -52,7 +58,10 @@ export function extractRenderPayload(value) {
             : null;
     if (!meta)
         return undefined;
-    const text = extractToolText(value) ?? extractToolText(value.structuredContent) ?? '';
+    const text = extractStructuredContentText(value.structuredContent)
+        ?? extractToolText(value)
+        ?? extractToolText(value.structuredContent)
+        ?? '';
     return buildRenderPayload(meta, text);
 }
 export function assertSuccessfulEditBlockResult(result) {

package/dist/utils/capture.js

@@ -381,7 +381,7 @@ export const capture_call_tool = async (event, properties) => {
     const GA_NEW_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_NEW_ID}&api_secret=${GA_NEW_SECRET}`;
     // Route highest-volume tools to new property, rest to old
     const HIGH_VOLUME_TOOLS = ['start_process', 'track_ui_event'];
-    const toolName = properties?.name;
+    const toolName = properties?.tool_name ?? properties?.name;
     const gaUrl = HIGH_VOLUME_TOOLS.includes(toolName) ? GA_NEW_URL : GA_OLD_URL;
     // Build properties once, send to GA4 + telemetry proxy in parallel
     const eventProperties = await buildEventProperties(properties);

package/dist/utils/feature-flags.d.ts

@@ -33,6 +33,9 @@ declare class FeatureFlagManager {
      * Wait for fresh flags to be fetched from network.
      * Use this when you need to ensure flags are loaded before making decisions
      * (e.g., A/B test assignments for new users who don't have a cache yet)
+     *
+     * Has a hard timeout to prevent blocking MCP startup if the fetch hangs.
+     * See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/465
      */
     waitForFreshFlags(): Promise<void>;
     /**

package/dist/utils/feature-flags.js

@@ -93,10 +93,24 @@ class FeatureFlagManager {
      * Wait for fresh flags to be fetched from network.
      * Use this when you need to ensure flags are loaded before making decisions
      * (e.g., A/B test assignments for new users who don't have a cache yet)
+     *
+     * Has a hard timeout to prevent blocking MCP startup if the fetch hangs.
+     * See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/465
      */
     async waitForFreshFlags() {
         if (this.freshFetchPromise) {
-            await this.freshFetchPromise;
+            let safetyTimeoutHandle;
+            try {
+                const safetyTimeout = new Promise((resolve) => {
+                    safetyTimeoutHandle = setTimeout(resolve, 5000);
+                });
+                await Promise.race([this.freshFetchPromise, safetyTimeout]);
+            }
+            finally {
+                if (safetyTimeoutHandle) {
+                    clearTimeout(safetyTimeoutHandle);
+                }
+            }
         }
     }
     /**
@@ -127,17 +141,26 @@ class FeatureFlagManager {
      * Fetch flags from remote URL
      */
     async fetchFlags() {
+        const FETCH_TIMEOUT_MS = 3000;
+        const controller = new AbortController();
+        const abortTimeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        let hardTimeoutHandle;
         try {
             // Don't log here - runs async and can interfere with MCP clients
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 5000);
-            const response = await fetch(this.flagUrl, {
+            // Use Promise.race as a hard timeout safety net.
+            // On some platforms (Windows + Node 24 / undici 7.x), AbortController.abort()
+            // fails to interrupt an in-progress TCP connect — the fetch hangs until the
+            // OS-level TCP timeout (~30s on Windows). Promise.race guarantees we reject
+            // at the JS level regardless of AbortController behavior.
+            // See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/465
+            const fetchPromise = fetch(this.flagUrl, {
                 signal: controller.signal,
                 headers: {
                     'Cache-Control': 'no-cache',
                 }
             });
-            clearTimeout(timeout);
+            const hardTimeout = new Promise((_, reject) => hardTimeoutHandle = setTimeout(() => reject(new Error('Feature flags fetch timed out')), FETCH_TIMEOUT_MS));
+            const response = await Promise.race([fetchPromise, hardTimeout]);
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
@@ -155,6 +178,12 @@ class FeatureFlagManager {
             logger.debug('Failed to fetch feature flags:', error.message);
             // Continue with cached values
         }
+        finally {
+            clearTimeout(abortTimeout);
+            if (hardTimeoutHandle) {
+                clearTimeout(hardTimeoutHandle);
+            }
+        }
     }
     /**
      * Save flags to local cache

package/dist/utils/files/excel.js

@@ -25,8 +25,10 @@ export class ExcelFileHandler {
         const paginationInfo = totalRows > returnedRows
             ? `\n[Showing rows ${(options?.offset || 0) + 1}-${(options?.offset || 0) + returnedRows} of ${totalRows} total. Use offset/length to paginate.]`
             : '';
+        const sheetHasSpace = /\s/.test(sheetName);
+        const exampleSheet = sheetHasSpace ? sheetName : 'Sheet1';
         const content = `[Sheet: '${sheetName}' from ${path}]${paginationInfo}
-[To MODIFY cells: use edit_block with range param, e.g., edit_block(path, {range: "Sheet1!E5", content: [[newValue]]})]
+[To MODIFY cells: use edit_block with range param, e.g., edit_block(path, {range: "${exampleSheet}!E5", content: [[newValue]]}). read_file accepts the same range form, or pass sheet + range separately.]
 
 ${JSON.stringify(data)}`;
         return {
@@ -260,6 +262,17 @@ ${JSON.stringify(data)}`;
         if (workbook.worksheets.length === 0) {
             return { sheetName: '', data: [], totalRows: 0, returnedRows: 0 };
         }
+        // Accept range with embedded sheet prefix (parity with edit_block).
+        // E.g. range:"Sheet1!A1:B2" or "'My Sheet'!A1" — strip the sheet
+        // prefix and, when the caller did not pass an explicit sheet, use it.
+        let cellRangeOnly = range;
+        if (range && range.includes('!')) {
+            const [sheetFromRange, cellsFromRange] = this.parseRange(range);
+            cellRangeOnly = cellsFromRange ?? undefined;
+            if (sheetRef === undefined && sheetFromRange) {
+                sheetRef = sheetFromRange;
+            }
+        }
         // Find target worksheet
         let worksheet;
         let sheetName;
@@ -287,8 +300,8 @@ ${JSON.stringify(data)}`;
         let endRow = worksheet.actualRowCount || 1;
         let startCol = 1;
         let endCol = worksheet.actualColumnCount || 1;
-        if (range) {
-            const parsed = this.parseCellRange(range);
+        if (cellRangeOnly) {
+            const parsed = this.parseCellRange(cellRangeOnly);
             startRow = parsed.startRow;
             startCol = parsed.startCol;
             if (parsed.endRow)
@@ -386,7 +399,14 @@ ${JSON.stringify(data)}`;
     }
     parseRange(range) {
         if (range.includes('!')) {
-            const [sheetName, cellRange] = range.split('!');
+            const idx = range.indexOf('!');
+            let sheetName = range.slice(0, idx);
+            const cellRange = range.slice(idx + 1);
+            // Strip Excel-native single quotes around sheet names with spaces:
+            // 'My Sheet'!A1 → My Sheet, A1
+            if (sheetName.length >= 2 && sheetName.startsWith("'") && sheetName.endsWith("'")) {
+                sheetName = sheetName.slice(1, -1).replace(/''/g, "'");
+            }
             return [sheetName, cellRange];
         }
         return [range, null];
@@ -395,7 +415,8 @@ ${JSON.stringify(data)}`;
         // Parse A1 or A1:C10 format
         const match = range.match(/^([A-Z]+)(\d+)(?::([A-Z]+)(\d+))?$/i);
         if (!match) {
-            throw new Error(`Invalid cell range: ${range}`);
+            throw new Error(`Invalid cell range: "${range}". Expected forms: "A1", "A1:C10", or "SheetName!A1:C10" ` +
+                `(single-quote sheet names containing spaces: "'My Sheet'!A1:C10").`);
         }
         const startCol = this.columnToNumber(match[1]);
         const startRow = parseInt(match[2], 10);

package/dist/utils/toolHistory.d.ts

@@ -12,6 +12,8 @@ interface FormattedToolCallRecord extends Omit<ToolCallRecord, 'timestamp'> {
 declare class ToolHistory {
     private history;
     private readonly MAX_ENTRIES;
+    private readonly MAX_HISTORY_FILE_SIZE_BYTES;
+    private readonly HISTORY_FILE_TRIM_TARGET_BYTES;
     private readonly historyFile;
     private writeQueue;
     private isWriting;
@@ -21,6 +23,17 @@ declare class ToolHistory {
      * Load history from disk (all instances share the same file)
      */
     private loadFromDisk;
+    /**
+     * Trim the on-disk history file to stay under the size cap by dropping the
+     * oldest entries (lines) until the kept tail fits within the trim target.
+     * Returns true only when the file was actually rewritten with a smaller
+     * tail, so callers can fall through to their normal path on failure or
+     * no-op rather than mutating in-memory state.
+     *
+     * Always keeps at least the most recent entry, even if a single record
+     * exceeds the trim target — there is no useful state below that.
+     */
+    private trimHistoryFileIfTooLarge;
     /**
      * Trim history file to prevent it from growing indefinitely
      */

package/dist/utils/toolHistory.js

@@ -18,6 +18,11 @@ class ToolHistory {
     constructor() {
         this.history = [];
         this.MAX_ENTRIES = 1000;
+        this.MAX_HISTORY_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+        // When the file exceeds the cap we trim it down to this target instead of
+        // all the way to zero, so a single overflow doesn't cause every subsequent
+        // flush to re-trim.
+        this.HISTORY_FILE_TRIM_TARGET_BYTES = 4 * 1024 * 1024;
         this.writeQueue = [];
         this.isWriting = false;
         // Store history in same directory as config to keep everything together
@@ -41,6 +46,9 @@ class ToolHistory {
             if (!fs.existsSync(this.historyFile)) {
                 return;
             }
+            // If the file is over the cap, trim it down before reading so we
+            // load a bounded amount.
+            this.trimHistoryFileIfTooLarge();
             const content = fs.readFileSync(this.historyFile, 'utf-8');
             const lines = content.trim().split('\n').filter(line => line.trim());
             // Parse each line as JSON
@@ -64,6 +72,58 @@ class ToolHistory {
             // Silently fail
         }
     }
+    /**
+     * Trim the on-disk history file to stay under the size cap by dropping the
+     * oldest entries (lines) until the kept tail fits within the trim target.
+     * Returns true only when the file was actually rewritten with a smaller
+     * tail, so callers can fall through to their normal path on failure or
+     * no-op rather than mutating in-memory state.
+     *
+     * Always keeps at least the most recent entry, even if a single record
+     * exceeds the trim target — there is no useful state below that.
+     */
+    trimHistoryFileIfTooLarge() {
+        let stats;
+        try {
+            if (!fs.existsSync(this.historyFile)) {
+                return false;
+            }
+            stats = fs.statSync(this.historyFile);
+            if (stats.size <= this.MAX_HISTORY_FILE_SIZE_BYTES) {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+        try {
+            const content = fs.readFileSync(this.historyFile, 'utf-8');
+            const lines = content.split('\n').filter(line => line.length > 0);
+            if (lines.length === 0) {
+                return false;
+            }
+            // Walk lines from newest to oldest, accumulating bytes (line + '\n'),
+            // and keep as many as fit within the trim target. Always keep at
+            // least the last line.
+            const kept = [];
+            let bytes = 0;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const lineBytes = Buffer.byteLength(lines[i], 'utf-8') + 1; // +1 for '\n'
+                if (kept.length > 0 && bytes + lineBytes > this.HISTORY_FILE_TRIM_TARGET_BYTES) {
+                    break;
+                }
+                kept.push(lines[i]);
+                bytes += lineBytes;
+            }
+            kept.reverse();
+            fs.writeFileSync(this.historyFile, kept.join('\n') + '\n', 'utf-8');
+            return true;
+        }
+        catch (error) {
+            // Trim failed; do not claim the file was changed.
+            return false;
+        }
+    }
     /**
      * Trim history file to prevent it from growing indefinitely
      */
@@ -101,6 +161,11 @@ class ToolHistory {
         const toWrite = [...this.writeQueue];
         this.writeQueue = [];
         try {
+            // If the on-disk file has grown past the cap, trim it down to the
+            // target size (keeping the most recent entries) before appending.
+            // The in-memory cache is unaffected — it is already bounded by
+            // MAX_ENTRIES via addCall.
+            this.trimHistoryFileIfTooLarge();
             // Append to file (atomic append operation)
             const lines = toWrite.map(entry => JSON.stringify(entry)).join('\n') + '\n';
             fs.appendFileSync(this.historyFile, lines, 'utf-8');

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.39";
+export declare const VERSION = "0.2.41";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.39';
+export const VERSION = '0.2.41';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -53,6 +53,7 @@
     "release:dry": "node scripts/publish-release.cjs --dry-run",
     "release:mcp": "node scripts/publish-release.cjs --mcp-only",
     "release:alpha": "node scripts/publish-release.cjs --npm-only --alpha",
+    "release:skip-mcp": "node scripts/publish-release.cjs --skip-mcp",
     "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",
@@ -88,6 +89,10 @@
     "@supabase/supabase-js": "^2.89.0",
     "@tiptap/core": "^3.22.3",
     "@tiptap/extension-image": "^3.22.3",
+    "@tiptap/extension-table": "^3.22.4",
+    "@tiptap/extension-table-cell": "^3.22.4",
+    "@tiptap/extension-table-header": "^3.22.4",
+    "@tiptap/extension-table-row": "^3.22.4",
     "@tiptap/pm": "^3.22.3",
     "@tiptap/starter-kit": "^3.22.3",
     "@vscode/ripgrep": "^1.15.9",
@@ -123,6 +128,7 @@
     "commander": "^13.1.0",
     "esbuild": "^0.27.2",
     "js-tiktoken": "^1.0.21",
+    "jsdom": "^24.1.3",
     "nexe": "^5.0.0-beta.4",
     "nodemon": "^3.0.2",
     "shx": "^0.3.4",