@wonderwhy-er/desktop-commander 0.2.36 → 0.2.38

package/dist/handlers/filesystem-handlers.js

@@ -5,7 +5,6 @@ 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
@@ -100,9 +99,7 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'unsupported',
-                    content: ''
                 },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         // Handle image files
@@ -124,28 +121,26 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'image',
-                    content: imageSummary,
                     imageData,
                     mimeType: fileResult.mimeType
-                },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
+                }
             };
         }
         else {
-            // For all other files, return as text
+            // For all other files, return as text.
+            // structuredContent carries only file metadata (no content duplication);
+            // the widget reads text from the MCP content array.
             const textContent = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('utf8');
-            const previewFileType = resolvePreviewFileType(resolvedFilePath);
+            const fileType = resolvePreviewFileType(resolvedFilePath);
             return {
                 content: [{ type: "text", text: textContent }],
                 structuredContent: {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
-                    fileType: previewFileType,
-                    content: textContent
+                    fileType,
                 },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
     };

package/dist/handlers/macos-control-handlers.d.ts

@@ -0,0 +1,16 @@
+import { ServerResult } from '../types.js';
+export declare function handleMacosAxStatus(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxListApps(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxListElements(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxFind(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxGetState(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxFindAndClick(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxClick(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxType(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxKey(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxActivate(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxWaitFor(args: unknown): Promise<ServerResult>;
+export declare function handleMacosAxBatch(args: unknown): Promise<ServerResult>;
+export declare function handleElectronDebugAttach(args: unknown): Promise<ServerResult>;
+export declare function handleElectronDebugEval(args: unknown): Promise<ServerResult>;
+export declare function handleElectronDebugDisconnect(args: unknown): Promise<ServerResult>;

package/dist/handlers/macos-control-handlers.js

@@ -0,0 +1,81 @@
+import { MacosAxStatusArgsSchema, MacosAxListAppsArgsSchema, MacosAxListElementsArgsSchema, MacosAxFindArgsSchema, MacosAxGetStateArgsSchema, MacosAxFindAndClickArgsSchema, MacosAxClickArgsSchema, MacosAxTypeArgsSchema, MacosAxKeyArgsSchema, MacosAxActivateArgsSchema, MacosAxWaitForArgsSchema, MacosAxBatchArgsSchema, ElectronDebugAttachArgsSchema, ElectronDebugEvalArgsSchema, ElectronDebugDisconnectArgsSchema, } from '../tools/schemas.js';
+import { macosControlOrchestrator } from '../tools/macos-control/orchestrator.js';
+function toServerResult(result) {
+    if (!result?.ok) {
+        const message = result?.error?.message || 'macOS control request failed';
+        const code = result?.error?.code ? ` (${result.error.code})` : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error${code}: ${message}`,
+                }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(result.data ?? {}, null, 2),
+            }],
+    };
+}
+export async function handleMacosAxStatus(args) {
+    MacosAxStatusArgsSchema.parse(args || {});
+    return toServerResult(await macosControlOrchestrator.axStatus());
+}
+export async function handleMacosAxListApps(args) {
+    MacosAxListAppsArgsSchema.parse(args || {});
+    return toServerResult(await macosControlOrchestrator.axListApps());
+}
+export async function handleMacosAxListElements(args) {
+    const parsed = MacosAxListElementsArgsSchema.parse(args || {});
+    return toServerResult(await macosControlOrchestrator.axListElements(parsed));
+}
+export async function handleMacosAxFind(args) {
+    const parsed = MacosAxFindArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axFind(parsed));
+}
+export async function handleMacosAxGetState(args) {
+    const parsed = MacosAxGetStateArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axGetState(parsed));
+}
+export async function handleMacosAxFindAndClick(args) {
+    const parsed = MacosAxFindAndClickArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axFindAndClick(parsed));
+}
+export async function handleMacosAxClick(args) {
+    const parsed = MacosAxClickArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axClick(parsed));
+}
+export async function handleMacosAxType(args) {
+    const parsed = MacosAxTypeArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axType(parsed.text));
+}
+export async function handleMacosAxKey(args) {
+    const parsed = MacosAxKeyArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axKey(parsed.key, parsed.modifiers ?? []));
+}
+export async function handleMacosAxActivate(args) {
+    const parsed = MacosAxActivateArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axActivate(parsed.app));
+}
+export async function handleMacosAxWaitFor(args) {
+    const parsed = MacosAxWaitForArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axWaitFor(parsed));
+}
+export async function handleMacosAxBatch(args) {
+    const parsed = MacosAxBatchArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.axBatch(parsed.commands, parsed.stopOnError));
+}
+export async function handleElectronDebugAttach(args) {
+    const parsed = ElectronDebugAttachArgsSchema.parse(args || {});
+    return toServerResult(await macosControlOrchestrator.electronDebugAttach(parsed));
+}
+export async function handleElectronDebugEval(args) {
+    const parsed = ElectronDebugEvalArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.electronDebugEval(parsed));
+}
+export async function handleElectronDebugDisconnect(args) {
+    const parsed = ElectronDebugDisconnectArgsSchema.parse(args);
+    return toServerResult(await macosControlOrchestrator.electronDebugDisconnect(parsed));
+}

package/dist/lib.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Library entry point for the DC Electron app worker thread.
+ * Exports server, configManager, and MCP SDK classes so the worker
+ * can import everything from a single bundled file instead of
+ * hundreds of individual module files.
+ */
+export { server } from './server.js';
+export { configManager } from './config-manager.js';
+export { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+export { Client } from '@modelcontextprotocol/sdk/client/index.js';

package/dist/lib.js

@@ -0,0 +1,10 @@
+/**
+ * Library entry point for the DC Electron app worker thread.
+ * Exports server, configManager, and MCP SDK classes so the worker
+ * can import everything from a single bundled file instead of
+ * hundreds of individual module files.
+ */
+export { server } from './server.js';
+export { configManager } from './config-manager.js';
+export { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+export { Client } from '@modelcontextprotocol/sdk/client/index.js';

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 Initialization 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)
      */

package/dist/server.js

@@ -21,7 +21,7 @@ import { handleWelcomePageOnboarding } from './utils/welcome-onboarding.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
-import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
+import { buildUiToolMeta, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
 import { listUiResources, readUiResource } from './ui/resources.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
@@ -167,6 +167,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true),
                 annotations: {
                     title: "Get Configuration",
                     readOnlyHint: true,
@@ -242,6 +243,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - PDF: Extracts text content as markdown with page structure
                           * offset/length work as page pagination (0-based)
                           * Includes embedded images when available
+                        - DOCX (.docx): Two modes depending on parameters:
+                          * DEFAULT (no offset/length): Returns a text-bearing outline — shows paragraphs with text,
+                            tables with cell content, styles, image refs. Skips shapes/drawings/SVG noise.
+                            Each element shows its body index [0], [1], etc.
+                          * WITH offset/length: Returns raw pretty-printed XML with line pagination.
+                            Use this to drill into specific sections or see the actual XML for editing.
+                          * EDITING WORKFLOW: 1) read_file to get outline, 2) read_file with offset/length
+                            to see raw XML around what you want to edit, 3) edit_block with old_string/new_string
+                            using XML fragments copied from the read output.
+                          * IMPORTANT: offset MUST be non-zero to get raw XML (use offset=1 to start from line 1).
+                            offset=0 always returns the outline regardless of length.
+                          * For BULK changes (translation, mass replacements): use start_process with Python
+                            zipfile module to find/replace all <w:t> elements at once.
 
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
@@ -279,6 +293,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Write or append to file contents.
 
                         IMPORTANT: DO NOT use this tool to create PDF files. Use 'write_pdf' for all PDF creation tasks.
+                        DO NOT use this tool to edit DOCX files. Use 'edit_block' with old_string/new_string instead.
+                        To CREATE a new DOCX, use write_file with .docx extension — text content with markdown headings (#, ##, ###) is converted to styled DOCX paragraphs.
 
                         CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
                         This is the normal, recommended way to write files - not an emergency measure.
@@ -657,6 +673,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - new_string: Replacement text
                         - expected_replacements: Optional number of replacements (default: 1)
 
+                        DOCX FILES (.docx) - XML Find/Replace mode:
+                        Takes same parameters as text files (old_string, new_string, expected_replacements).
+                        Operates on the pretty-printed XML inside the DOCX — the same XML you see from
+                        read_file with offset/length. Copy XML fragments from read output as old_string.
+                        After editing, the XML is repacked into a valid DOCX.
+                        Also searches headers/footers if not found in document body.
+                        Examples:
+                        - Replace text: old_string="<w:t>Old Text</w:t>" new_string="<w:t>New Text</w:t>"
+                        - Change style: old_string='<w:pStyle w:val="Normal"/>' new_string='<w:pStyle w:val="Heading1"/>'
+                        - Add content: include surrounding XML context in old_string, add new elements in new_string
+
                         By default, replaces only ONE occurrence of the search text.
                         To replace multiple occurrences, provide expected_replacements with
                         the exact number of matches expected.
@@ -1078,6 +1105,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
             telemetryData.set_config_value_key_name = args.key;
+            telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
         }
         if (name === 'get_prompts' && args && typeof args === 'object') {
             const promptArgs = args;

package/dist/test-docx.d.ts

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