@wonderwhy-er/desktop-commander 0.2.34 → 0.2.35

package/dist/tools/docx/utils.js

@@ -0,0 +1,299 @@
+/**
+ * DOCX Utility Functions
+ * Helper functions for DOCX operations, validation, and data transformation
+ */
+import fs from 'fs/promises';
+import path from 'path';
+// Import types from docx for image handling
+// @ts-ignore - docx library has incomplete type definitions but exports exist at runtime
+import * as docx from 'docx';
+const { ImageRun, } = docx;
+import { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
+/**
+ * Check if a string is a valid data URL
+ */
+export function isDataUrl(src) {
+    return src.startsWith('data:') && src.includes('base64,');
+}
+/**
+ * Check if a source is a URL (http/https)
+ */
+export function isUrl(src) {
+    return src.startsWith('http://') || src.startsWith('https://');
+}
+/**
+ * Parse data URL into buffer
+ * @returns Buffer if successful, null if invalid
+ */
+export function parseDataUrl(dataUrl) {
+    try {
+        const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+        if (!match)
+            return null;
+        return Buffer.from(match[2], 'base64');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve image path relative to base directory
+ */
+export function resolveImagePath(imagePath, baseDir) {
+    if (path.isAbsolute(imagePath) || isUrl(imagePath) || isDataUrl(imagePath)) {
+        return imagePath;
+    }
+    if (!baseDir) {
+        return path.resolve(imagePath);
+    }
+    return path.join(baseDir, imagePath);
+}
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate image file
+ */
+export async function validateImageFile(imagePath) {
+    if (isDataUrl(imagePath)) {
+        const buffer = parseDataUrl(imagePath);
+        if (!buffer) {
+            return { valid: false, error: 'Invalid data URL format' };
+        }
+        return { valid: true };
+    }
+    if (isUrl(imagePath)) {
+        // For URLs, we'll validate during fetch
+        return { valid: true };
+    }
+    const exists = await fileExists(imagePath);
+    if (!exists) {
+        return { valid: false, error: `Image file not found: ${imagePath}` };
+    }
+    // Check file extension
+    const ext = path.extname(imagePath).toLowerCase();
+    const validExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg'];
+    if (!validExtensions.includes(ext)) {
+        return { valid: false, error: `Unsupported image format: ${ext}` };
+    }
+    return { valid: true };
+}
+/**
+ * Escape special regex characters for literal string matching
+ */
+export function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Validate markdown table format
+ */
+export function isValidMarkdownTable(markdown) {
+    const lines = markdown.trim().split('\n');
+    if (lines.length < 2)
+        return false;
+    // Check header row
+    const headerLine = lines[0].trim();
+    if (!headerLine.startsWith('|') || !headerLine.endsWith('|'))
+        return false;
+    // Check separator row
+    const separatorLine = lines[1].trim();
+    if (!separatorLine.startsWith('|') || !separatorLine.endsWith('|'))
+        return false;
+    // Verify separator contains dashes
+    const separatorPattern = /^(\|\s*:?-{2,}\s*:?\s*)+\|$/;
+    if (!separatorPattern.test(separatorLine))
+        return false;
+    return true;
+}
+/**
+ * Build a markdown table from a 2D array of rows
+ */
+export function buildMarkdownTableFromRows(rows) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const header = rows[0];
+    const dataRows = rows.slice(1);
+    const headerLine = `| ${header.join(' | ')} |`;
+    const separatorLine = `| ${header.map(() => '---').join(' | ')} |`;
+    const dataLines = dataRows.map((r) => `| ${r.join(' | ')} |`);
+    return [headerLine, separatorLine, ...dataLines].join('\n');
+}
+/**
+ * Parse markdown table into 2D array
+ */
+export function parseMarkdownTable(markdown) {
+    if (!isValidMarkdownTable(markdown)) {
+        return null;
+    }
+    const lines = markdown.trim().split('\n');
+    const rows = [];
+    for (let i = 0; i < lines.length; i++) {
+        // Skip separator line
+        if (i === 1)
+            continue;
+        const line = lines[i].trim();
+        const cells = line
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map(cell => cell.trim());
+        rows.push(cells);
+    }
+    return rows;
+}
+/**
+ * Get MIME type from file extension or data URL
+ */
+export function getMimeType(source) {
+    if (isDataUrl(source)) {
+        const match = source.match(/^data:([^;]+);/);
+        return match ? match[1] : null;
+    }
+    const ext = path.extname(source).toLowerCase();
+    const mimeTypes = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.bmp': 'image/bmp',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+    };
+    return mimeTypes[ext] || null;
+}
+/**
+ * Format file size in human-readable format
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+/**
+ * Normalize line endings to \n
+ */
+export function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+/**
+ * Split markdown into lines, preserving empty lines
+ */
+export function splitMarkdownLines(markdown) {
+    return normalizeLineEndings(markdown).split('\n');
+}
+/**
+ * Validate DOCX file path
+ */
+export function isDocxPath(filePath) {
+    return filePath.toLowerCase().endsWith('.docx');
+}
+/**
+ * Extract file name without extension
+ */
+export function getFileNameWithoutExtension(filePath) {
+    const basename = path.basename(filePath);
+    return basename.replace(/\.docx$/i, '');
+}
+// Re-export error handling from errors module
+export { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
+/**
+ * Load and prepare an image for DOCX embedding
+ * Handles both local files and data URLs
+ *
+ * @param imagePath - Path to image file or data URL
+ * @param altText - Alternative text for the image
+ * @param baseDir - Base directory for resolving relative paths
+ * @returns Prepared image data ready for embedding
+ */
+export async function prepareImageForDocx(imagePath, altText = '', baseDir) {
+    return withErrorContext(async () => {
+        let buffer;
+        let mimeType = 'image/png'; // Default
+        // Handle data URL
+        if (isDataUrl(imagePath)) {
+            const parsed = parseDataUrl(imagePath);
+            if (!parsed) {
+                throw new DocxError('Invalid data URL format', DocxErrorCode.INVALID_IMAGE_DATA_URL, { imagePath: imagePath.substring(0, 50) });
+            }
+            buffer = parsed;
+            // Extract MIME type from data URL
+            const mimeMatch = imagePath.match(/^data:([^;]+);/);
+            if (mimeMatch) {
+                mimeType = mimeMatch[1];
+            }
+        }
+        else {
+            // Handle file path
+            const resolved = resolveImagePath(imagePath, baseDir);
+            // Validate image file
+            const validation = await validateImageFile(resolved);
+            if (!validation.valid) {
+                throw new DocxError(validation.error || 'Invalid image file', DocxErrorCode.INVALID_IMAGE_FILE, { imagePath: resolved });
+            }
+            // Read image file
+            try {
+                buffer = await fs.readFile(resolved);
+            }
+            catch (error) {
+                throw new DocxError(`Failed to read image file: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_READ_FAILED, { imagePath: resolved });
+            }
+            // Determine MIME type from file extension
+            const ext = path.extname(resolved).toLowerCase();
+            const mimeTypes = {
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.bmp': 'image/bmp',
+                '.webp': 'image/webp',
+            };
+            mimeType = mimeTypes[ext] || 'image/png';
+        }
+        return {
+            buffer,
+            altText: altText || path.basename(imagePath),
+            mimeType,
+            // Default dimensions - can be customized
+            width: 600,
+            height: 400,
+        };
+    }, DocxErrorCode.IMAGE_PREPARATION_FAILED, { imagePath });
+}
+/**
+ * Create an ImageRun instance for embedding in DOCX paragraphs
+ * This is a lower-level utility for direct image insertion
+ *
+ * @param imageData - Prepared image data
+ * @returns ImageRun instance ready to be added to a paragraph
+ */
+export function createImageRun(imageData) {
+    try {
+        return new ImageRun({
+            data: imageData.buffer,
+            transformation: {
+                width: imageData.width || 600,
+                height: imageData.height || 400,
+            },
+            altText: {
+                title: imageData.altText,
+                description: imageData.altText,
+            },
+        });
+    }
+    catch (error) {
+        throw new DocxError(`Failed to create image run: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_RUN_CREATION_FAILED);
+    }
+}

package/dist/tools/docx/validators.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DOCX Validation Utilities
+ *
+ * Input validation for paths, operations arrays, and image dimensions.
+ *
+ * @module docx/validators
+ */
+/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
+export declare function validateDocxPath(path: string): void;
+/** Validate that an operations array is a non-empty array. */
+export declare function validateOperations(operations: unknown[]): void;
+/** Validate optional image width and height (must be positive and finite). */
+export declare function validateImageDimensions(width?: number, height?: number): void;

package/dist/tools/docx/validators.js

@@ -0,0 +1,40 @@
+/**
+ * DOCX Validation Utilities
+ *
+ * Input validation for paths, operations arrays, and image dimensions.
+ *
+ * @module docx/validators
+ */
+import { DocxError, DocxErrorCode } from './errors.js';
+import { isDocxPath } from './utils/paths.js';
+/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
+export function validateDocxPath(path) {
+    if (!path || typeof path !== 'string') {
+        throw new DocxError('DOCX path must be a non-empty string', DocxErrorCode.INVALID_PATH, { path });
+    }
+    const normalised = path.trim();
+    if (!normalised) {
+        throw new DocxError('DOCX path cannot be empty', DocxErrorCode.INVALID_PATH, { path });
+    }
+    if (!isDocxPath(normalised)) {
+        throw new DocxError('Invalid DOCX path: must end with .docx', DocxErrorCode.INVALID_PATH, { path: normalised });
+    }
+}
+/** Validate that an operations array is a non-empty array. */
+export function validateOperations(operations) {
+    if (!Array.isArray(operations)) {
+        throw new DocxError('Operations must be an array', DocxErrorCode.OPERATION_FAILED, { operations });
+    }
+    if (operations.length === 0) {
+        throw new DocxError('Operations array cannot be empty', DocxErrorCode.OPERATION_FAILED, { operations });
+    }
+}
+/** Validate optional image width and height (must be positive and finite). */
+export function validateImageDimensions(width, height) {
+    if (width !== undefined && (typeof width !== 'number' || width <= 0 || !Number.isFinite(width))) {
+        throw new DocxError('Image width must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { width });
+    }
+    if (height !== undefined && (typeof height !== 'number' || height <= 0 || !Number.isFinite(height))) {
+        throw new DocxError('Image height must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { height });
+    }
+}

package/dist/utils/capture.js

@@ -226,15 +226,15 @@ export const captureBase = async (captureURL, event, properties) => {
     }
 };
 export const capture_call_tool = async (event, properties) => {
-    const GA_MEASUREMENT_ID = 'G-35YKFM782B'; // Replace with your GA4 Measurement ID
-    const GA_API_SECRET = 'qM5VNk6aQy6NN5s-tCppZw'; // Replace with your GA4 API Secret
+    const GA_MEASUREMENT_ID = 'G-8L163XZ1CE'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = 'hNxh4TK2TnSy4oLZn4RwTA'; // 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}`;
     const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
     return await captureBase(GA_BASE_URL, event, properties);
 };
 export const capture = async (event, properties) => {
-    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_MEASUREMENT_ID = 'G-F3GK01G39Y'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = 'SqdcIAweSQS1RQErURMdEA'; // 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}`;
     const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
     return await captureBase(GA_BASE_URL, event, properties);

package/dist/utils/files/docx.d.ts

@@ -0,0 +1,41 @@
+/**
+ * DOCX File Handler
+ * Implements FileHandler interface for Microsoft Word documents
+ */
+import { FileHandler, FileResult, FileInfo, ReadOptions, EditResult } from './base.js';
+/**
+ * File handler for DOCX documents
+ * Extracts text as markdown with embedded images
+ */
+export declare class DocxFileHandler implements FileHandler {
+    private readonly extensions;
+    /**
+     * Check if this handler can handle the given file
+     */
+    canHandle(path: string): boolean;
+    /**
+     * Read DOCX content — extracts text as styled HTML (with embedded images).
+     * Uses direct DOCX XML parsing for style preservation, with mammoth.js fallback.
+     */
+    read(path: string, options?: ReadOptions): Promise<FileResult>;
+    /**
+     * Write DOCX file.
+     *
+     * - String content + 'rewrite': create new DOCX from HTML/markdown.
+     * - String content + 'append': append to existing DOCX → writes to {name}_v1.docx.
+     * - Array content: apply DocxOperation[] edits → writes to {name}_v1.docx.
+     * Original file is always preserved.
+     */
+    write(path: string, content: any, mode?: 'rewrite' | 'append'): Promise<void>;
+    /**
+     * Edit DOCX by applying high-level operations.
+     * Writes to {name}_v1.docx unless `options.outputPath` is provided.
+     */
+    editRange(path: string, range: string, content: any, options?: Record<string, any>): Promise<EditResult>;
+    /**
+     * Get DOCX file information including metadata.
+     */
+    getInfo(path: string): Promise<FileInfo>;
+    /** Get base directory for resolving relative image paths. */
+    private getBaseDir;
+}

package/dist/utils/files/docx.js

@@ -0,0 +1,245 @@
+/**
+ * DOCX File Handler
+ * Implements FileHandler interface for Microsoft Word documents
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { parseDocxToHtml, createDocxFromHtml, editDocxWithOperations, DocxError } from '../../tools/docx/index.js';
+import { convertToHtmlIfNeeded, generateOutputPath } from '../../tools/docx/utils/index.js';
+/**
+ * File handler for DOCX documents
+ * Extracts text as markdown with embedded images
+ */
+export class DocxFileHandler {
+    constructor() {
+        this.extensions = ['.docx'];
+    }
+    /**
+     * Check if this handler can handle the given file
+     */
+    canHandle(path) {
+        const ext = path.toLowerCase();
+        return this.extensions.some(e => ext.endsWith(e));
+    }
+    /**
+     * Read DOCX content — extracts text as styled HTML (with embedded images).
+     * Uses direct DOCX XML parsing for style preservation, with mammoth.js fallback.
+     */
+    async read(path, options) {
+        try {
+            const docxResult = await parseDocxToHtml(path, {
+                includeImages: true,
+                preserveFormatting: true
+            });
+            // Format the content for MCP response
+            let content = docxResult.html;
+            // Add status message if requested (default: true)
+            const includeStatusMessage = options?.includeStatusMessage !== false;
+            if (includeStatusMessage) {
+                const statusParts = [];
+                if (docxResult.metadata.title) {
+                    statusParts.push(`Title: "${docxResult.metadata.title}"`);
+                }
+                if (docxResult.metadata.author) {
+                    statusParts.push(`Author: ${docxResult.metadata.author}`);
+                }
+                if (docxResult.images.length > 0) {
+                    statusParts.push(`${docxResult.images.length} embedded images`);
+                }
+                if (docxResult.sections) {
+                    const headings = docxResult.sections.filter(s => s.type === 'heading').length;
+                    statusParts.push(`${headings} headings`);
+                }
+                if (statusParts.length > 0) {
+                    content = `[DOCX: ${statusParts.join(', ')}]\n\n${content}`;
+                }
+            }
+            return {
+                content,
+                mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                metadata: {
+                    isDocx: true,
+                    title: docxResult.metadata.title,
+                    author: docxResult.metadata.author,
+                    subject: docxResult.metadata.subject,
+                    description: docxResult.metadata.description,
+                    creationDate: docxResult.metadata.creationDate,
+                    modificationDate: docxResult.metadata.modificationDate,
+                    lastModifiedBy: docxResult.metadata.lastModifiedBy,
+                    revision: docxResult.metadata.revision,
+                    fileSize: docxResult.metadata.fileSize,
+                    images: docxResult.images,
+                    sections: docxResult.sections
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Error reading DOCX: ${errorMessage}`,
+                mimeType: 'text/plain',
+                metadata: {
+                    error: true,
+                    errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * Write DOCX file.
+     *
+     * - String content + 'rewrite': create new DOCX from HTML/markdown.
+     * - String content + 'append': append to existing DOCX → writes to {name}_v1.docx.
+     * - Array content: apply DocxOperation[] edits → writes to {name}_v1.docx.
+     * Original file is always preserved.
+     */
+    async write(path, content, mode = 'rewrite') {
+        const baseDir = path ? this.getBaseDir(path) : process.cwd();
+        // String content → treat as HTML (or markdown which will be converted)
+        if (typeof content === 'string') {
+            if (mode === 'append') {
+                // Append HTML/markdown — write to _v1 file, preserve original
+                const targetPath = await generateOutputPath(path);
+                const operations = [{
+                        type: 'appendMarkdown',
+                        markdown: content
+                    }];
+                const buffer = await editDocxWithOperations(path, operations, { baseDir });
+                await fs.writeFile(targetPath, buffer);
+            }
+            else {
+                const html = convertToHtmlIfNeeded(content);
+                const buffer = await createDocxFromHtml(html, { baseDir });
+                await fs.writeFile(path, buffer);
+            }
+            return;
+        }
+        // Array content → treat as DocxOperation[], write to _v1 file, preserve original
+        if (Array.isArray(content)) {
+            try {
+                await fs.access(path);
+            }
+            catch {
+                throw new Error(`Cannot modify DOCX: source file does not exist: ${path}. Use string content to create a new DOCX file.`);
+            }
+            const targetPath = await generateOutputPath(path);
+            const operations = content;
+            const buffer = await editDocxWithOperations(path, operations, { baseDir });
+            await fs.writeFile(targetPath, buffer);
+            return;
+        }
+        throw new Error('Unsupported content type for DOCX write. Expected HTML/markdown string or array of operations.');
+    }
+    /**
+     * Edit DOCX by applying high-level operations.
+     * Writes to {name}_v1.docx unless `options.outputPath` is provided.
+     */
+    async editRange(path, range, content, options) {
+        const baseDir = this.getBaseDir(path);
+        // Use provided outputPath, otherwise write to _v1 file
+        const outputPath = options?.outputPath ?? await generateOutputPath(path);
+        try {
+            await fs.access(path);
+        }
+        catch {
+            return {
+                success: false,
+                editsApplied: 0,
+                errors: [{
+                        location: range,
+                        error: `Cannot edit DOCX: source file does not exist: ${path}`
+                    }]
+            };
+        }
+        let operations;
+        if (typeof content === 'string') {
+            // Treat string content as HTML/markdown to append (will be converted to HTML internally)
+            operations = [{
+                    type: 'appendMarkdown',
+                    markdown: content
+                }];
+        }
+        else if (Array.isArray(content)) {
+            operations = content;
+        }
+        else {
+            return {
+                success: false,
+                editsApplied: 0,
+                errors: [{
+                        location: range,
+                        error: 'Unsupported content type for DOCX edit. Expected HTML/markdown string or array of operations.'
+                    }]
+            };
+        }
+        try {
+            const buffer = await editDocxWithOperations(path, operations, { baseDir, outputPath });
+            await fs.writeFile(outputPath, buffer);
+            return {
+                success: true,
+                editsApplied: operations.length
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                editsApplied: 0,
+                errors: [{
+                        location: range,
+                        error: errorMessage
+                    }]
+            };
+        }
+    }
+    /**
+     * Get DOCX file information including metadata.
+     */
+    async getInfo(path) {
+        try {
+            const stats = await fs.stat(path);
+            let metadata = { isDocx: true };
+            try {
+                const docxResult = await parseDocxToHtml(path, {
+                    includeImages: false,
+                    preserveFormatting: false,
+                });
+                metadata = {
+                    isDocx: true,
+                    title: docxResult.metadata.title,
+                    author: docxResult.metadata.author,
+                    subject: docxResult.metadata.subject,
+                    description: docxResult.metadata.description,
+                    creationDate: docxResult.metadata.creationDate,
+                    modificationDate: docxResult.metadata.modificationDate,
+                    lastModifiedBy: docxResult.metadata.lastModifiedBy,
+                    revision: docxResult.metadata.revision,
+                    imageCount: docxResult.images.length,
+                    sectionCount: docxResult.sections?.length,
+                };
+            }
+            catch {
+                // Non-critical — return basic info if parsing fails
+            }
+            return {
+                size: stats.size,
+                created: stats.birthtime,
+                modified: stats.mtime,
+                accessed: stats.atime,
+                isDirectory: false,
+                isFile: true,
+                permissions: (stats.mode & 0o777).toString(8),
+                fileType: 'binary',
+                metadata
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new DocxError(`Failed to get DOCX file info: ${message}`, 'GET_INFO_FAILED', { path });
+        }
+    }
+    /** Get base directory for resolving relative image paths. */
+    getBaseDir(docxPath) {
+        return docxPath ? path.dirname(docxPath) : process.cwd();
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.34";
+export declare const VERSION = "0.2.35";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.34';
+export const VERSION = '0.2.35';

package/package.json

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