@wonderwhy-er/desktop-commander 0.2.34 → 0.2.36

package/README.md

@@ -16,6 +16,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/server.js

@@ -1,5 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { getSystemInfo, getOSSpecificGuidance, getPathGuidance, getDevelopmentToolGuidance } from './utils/system-info.js';
 // Get system information once at startup
@@ -21,6 +21,8 @@ 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 { listUiResources, readUiResource } from './ui/resources.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
 function deferLog(level, message) {
@@ -47,11 +49,18 @@ export const server = new Server({
 });
 // Add handler for resources/list method
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    // Return an empty list of resources
     return {
-        resources: [],
+        resources: listUiResources(),
     };
 });
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const response = await readUiResource(uri);
+    if (response) {
+        return response;
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+});
 // Add handler for prompts/list method
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
     // Return an empty list of prompts
@@ -237,6 +246,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
                 annotations: {
                     title: "Read File or URL",
                     readOnlyHint: true,
@@ -1179,6 +1189,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 break;
+            case "track_ui_event":
+                try {
+                    result = await handlers.handleTrackUiEvent(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in track_ui_event handler: ${error}` });
+                    result = {
+                        content: [{ type: "text", text: `Error: Failed to track UI event` }],
+                        isError: true,
+                    };
+                }
+                break;
             case "give_feedback_to_desktop_commander":
                 try {
                     result = await giveFeedbackToDesktopCommander(args);
@@ -1265,12 +1287,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
         const duration = Date.now() - startTime;
         const EXCLUDED_TOOLS = [
-            'get_recent_tool_calls'
+            'get_recent_tool_calls',
+            'track_ui_event'
         ];
         if (!EXCLUDED_TOOLS.includes(name)) {
             toolHistory.addCall(name, args, result, duration);
         }
         // Track success or failure based on result
+        if (name === 'track_ui_event') {
+            return result;
+        }
         if (result.isError) {
             await usageTracker.trackFailure(name);
             console.log(`[FEEDBACK DEBUG] Tool ${name} failed, not checking feedback`);

package/dist/tools/docx/builders/html-builder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTML → DOCX Conversion (html-to-docx)
+ *
+ * Converts processed HTML content into a DOCX buffer, injecting the original
+ * document's default font and font size so unstyled text keeps its appearance.
+ *
+ * @module docx/builders/html-builder
+ */
+import type { DocxBuildOptions } from '../types.js';
+/**
+ * Create a DOCX Buffer from HTML content.
+ *
+ * @param html - HTML content to convert
+ * @param options - Build options (baseDir, documentDefaults, etc.)
+ * @returns DOCX file as a Buffer
+ */
+export declare function createDocxFromHtml(html: string, options?: DocxBuildOptions): Promise<Buffer>;

package/dist/tools/docx/builders/html-builder.js

@@ -0,0 +1,92 @@
+/**
+ * HTML → DOCX Conversion (html-to-docx)
+ *
+ * Converts processed HTML content into a DOCX buffer, injecting the original
+ * document's default font and font size so unstyled text keeps its appearance.
+ *
+ * @module docx/builders/html-builder
+ */
+import { createRequire } from 'module';
+import { DocxError, DocxErrorCode, withErrorContext } from '../errors.js';
+import { DEFAULT_BUILD_OPTIONS, HTML_WRAPPER_TEMPLATE } from '../constants.js';
+const require = createRequire(import.meta.url);
+const HTMLtoDOCX = require('html-to-docx');
+// ─── HTML Structure Helpers ──────────────────────────────────────────────────
+/** Build a `<style>` tag with the original document's default font/size as CSS `body` rules. */
+function buildDefaultStyleTag(defaults) {
+    if (!defaults)
+        return '';
+    const rules = [];
+    if (defaults.font)
+        rules.push(`font-family: '${defaults.font}'`);
+    if (defaults.fontSize)
+        rules.push(`font-size: ${defaults.fontSize}pt`);
+    if (rules.length === 0)
+        return '';
+    return `<style>body { ${rules.join('; ')}; }</style>`;
+}
+/**
+ * Ensure the HTML has a proper structure (DOCTYPE, `<html>`, `<head>`, `<body>`).
+ * Injects the document-default CSS into `<head>` when available.
+ */
+function ensureHtmlStructure(html, defaults) {
+    const trimmed = html.trim();
+    const styleTag = buildDefaultStyleTag(defaults);
+    if (!trimmed) {
+        const wrapped = HTML_WRAPPER_TEMPLATE.split('{content}').join('');
+        return styleTag ? wrapped.replace('</head>', `${styleTag}\n</head>`) : wrapped;
+    }
+    const lower = trimmed.toLowerCase();
+    const hasDoctype = lower.startsWith('<!doctype');
+    const hasHtml = lower.includes('<html');
+    const hasBody = lower.includes('<body');
+    // Already complete — inject styles only
+    if (hasDoctype && hasHtml && hasBody) {
+        if (styleTag && trimmed.includes('</head>')) {
+            return trimmed.replace('</head>', `${styleTag}\n</head>`);
+        }
+        return trimmed;
+    }
+    // Partial structure — add DOCTYPE, inject styles
+    if (hasHtml || hasBody) {
+        const result = `<!DOCTYPE html>\n${trimmed}`;
+        return styleTag && result.includes('</head>')
+            ? result.replace('</head>', `${styleTag}\n</head>`)
+            : result;
+    }
+    // Plain fragment — wrap fully
+    // Use split/join instead of replace to avoid $-pattern interpretation in base64 data URLs
+    const wrapped = HTML_WRAPPER_TEMPLATE.split('{content}').join(trimmed);
+    return styleTag ? wrapped.replace('</head>', `${styleTag}\n</head>`) : wrapped;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Create a DOCX Buffer from HTML content.
+ *
+ * @param html - HTML content to convert
+ * @param options - Build options (baseDir, documentDefaults, etc.)
+ * @returns DOCX file as a Buffer
+ */
+export async function createDocxFromHtml(html, options = {}) {
+    return withErrorContext(async () => {
+        if (!html?.trim()) {
+            throw new DocxError('HTML content cannot be empty', DocxErrorCode.DOCX_CREATE_FAILED, { htmlLength: 0 });
+        }
+        const defaults = options.documentDefaults;
+        const processedHtml = ensureHtmlStructure(html, defaults);
+        const docxOptions = {
+            table: { row: { cantSplit: true } },
+            footer: DEFAULT_BUILD_OPTIONS.footer,
+            pageNumber: DEFAULT_BUILD_OPTIONS.pageNumber,
+            font: defaults?.font || DEFAULT_BUILD_OPTIONS.font,
+            fontSize: defaults?.fontSize || DEFAULT_BUILD_OPTIONS.fontSize,
+            orientation: DEFAULT_BUILD_OPTIONS.orientation,
+            margins: { ...DEFAULT_BUILD_OPTIONS.margins },
+        };
+        const docxBuffer = await HTMLtoDOCX(processedHtml, null, docxOptions);
+        if (!docxBuffer || docxBuffer.length === 0) {
+            throw new DocxError('Failed to generate DOCX: empty buffer', DocxErrorCode.DOCX_CREATE_FAILED, { htmlLength: html.length });
+        }
+        return Buffer.from(docxBuffer);
+    }, DocxErrorCode.DOCX_CREATE_FAILED, { htmlLength: html.length });
+}

package/dist/tools/docx/builders/image.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Image builder — creates w:drawing elements and manages image relationships.
+ */
+import PizZip from 'pizzip';
+import type { DocxContentImage, InsertImageOp } from '../types.js';
+/**
+ * Build an image element and add it to the ZIP archive.
+ *
+ * @param doc The XML document
+ * @param zip The DOCX ZIP archive
+ * @param spec The image specification (from content or operation)
+ * @returns A w:p element containing the image drawing
+ */
+export declare function buildImageElement(doc: Document, zip: PizZip, spec: DocxContentImage | InsertImageOp): Promise<Element>;

package/dist/tools/docx/builders/image.js

@@ -0,0 +1,84 @@
+/**
+ * Image builder — creates w:drawing elements and manages image relationships.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { DOMParser } from '@xmldom/xmldom';
+import { addImageRelationship, ensureContentType } from '../relationships.js';
+import { escapeXmlAttr } from './utils.js';
+import { pixelsToEmu, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, NAMESPACES } from '../constants.js';
+/**
+ * Build an image element and add it to the ZIP archive.
+ *
+ * @param doc The XML document
+ * @param zip The DOCX ZIP archive
+ * @param spec The image specification (from content or operation)
+ * @returns A w:p element containing the image drawing
+ */
+export async function buildImageElement(doc, zip, spec) {
+    // Validate image exists
+    try {
+        await fs.access(spec.imagePath);
+    }
+    catch {
+        throw new Error(`Image file not found: ${spec.imagePath}`);
+    }
+    // Read image
+    const imgBuffer = await fs.readFile(spec.imagePath);
+    const ext = path.extname(spec.imagePath).toLowerCase();
+    const baseName = path.basename(spec.imagePath);
+    // Find next available media filename
+    let mediaIndex = 1;
+    while (zip.file(`word/media/image${mediaIndex}${ext}`)) {
+        mediaIndex++;
+    }
+    const mediaFileName = `image${mediaIndex}${ext}`;
+    // Add image to ZIP
+    zip.file(`word/media/${mediaFileName}`, imgBuffer);
+    // Add relationship
+    const rId = addImageRelationship(zip, mediaFileName);
+    // Ensure Content_Types entry
+    ensureContentType(zip, ext);
+    // Compute dimensions (EMU)
+    const widthPx = spec.width ?? DEFAULT_IMAGE_WIDTH;
+    const heightPx = spec.height ?? DEFAULT_IMAGE_HEIGHT;
+    const widthEmu = pixelsToEmu(widthPx);
+    const heightEmu = pixelsToEmu(heightPx);
+    // Build drawing XML
+    const altText = spec.altText ?? baseName;
+    const drawingXmlStr = buildDrawingXml(rId, widthEmu, heightEmu, altText, mediaFileName);
+    // Parse drawing XML into a paragraph
+    const drawingFragment = new DOMParser().parseFromString(`<w:p xmlns:w="${NAMESPACES.W}">` +
+        `<w:r>${drawingXmlStr}</w:r></w:p>`, 'application/xml');
+    return doc.importNode(drawingFragment.documentElement, true);
+}
+/**
+ * Build the inline w:drawing XML for an image reference.
+ */
+function buildDrawingXml(rId, widthEmu, heightEmu, altText, fileName) {
+    return (`<w:drawing xmlns:w="${NAMESPACES.W}">` +
+        `<wp:inline distT="0" distB="0" distL="0" distR="0" ` +
+        `xmlns:wp="${NAMESPACES.WP}">` +
+        `<wp:extent cx="${widthEmu}" cy="${heightEmu}"/>` +
+        `<wp:docPr id="1" name="${fileName}" descr="${escapeXmlAttr(altText)}"/>` +
+        `<a:graphic xmlns:a="${NAMESPACES.A}">` +
+        `<a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">` +
+        `<pic:pic xmlns:pic="${NAMESPACES.PIC}">` +
+        `<pic:nvPicPr>` +
+        `<pic:cNvPr id="0" name="${fileName}" descr="${escapeXmlAttr(altText)}"/>` +
+        `<pic:cNvPicPr/>` +
+        `</pic:nvPicPr>` +
+        `<pic:blipFill>` +
+        `<a:blip r:embed="${rId}" xmlns:r="${NAMESPACES.R}"/>` +
+        `<a:stretch><a:fillRect/></a:stretch>` +
+        `</pic:blipFill>` +
+        `<pic:spPr>` +
+        `<a:xfrm><a:off x="0" y="0"/><a:ext cx="${widthEmu}" cy="${heightEmu}"/></a:xfrm>` +
+        `<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>` +
+        `</pic:spPr>` +
+        `</pic:pic>` +
+        `</a:graphicData>` +
+        `</a:graphic>` +
+        `</wp:inline>` +
+        `</w:drawing>`);
+}

package/dist/tools/docx/builders/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DOCX element builders — Single Responsibility: build XML elements
+ * for paragraphs, tables, and images.
+ *
+ * These builders are shared between create.ts and ops/ modules to
+ * eliminate code duplication and ensure consistency.
+ */
+export { buildParagraph } from './paragraph.js';
+export { buildTable } from './table.js';
+export { buildImageElement } from './image.js';
+export { escapeXml, escapeXmlAttr } from './utils.js';

package/dist/tools/docx/builders/index.js

@@ -0,0 +1,11 @@
+/**
+ * DOCX element builders — Single Responsibility: build XML elements
+ * for paragraphs, tables, and images.
+ *
+ * These builders are shared between create.ts and ops/ modules to
+ * eliminate code duplication and ensure consistency.
+ */
+export { buildParagraph } from './paragraph.js';
+export { buildTable } from './table.js';
+export { buildImageElement } from './image.js';
+export { escapeXml, escapeXmlAttr } from './utils.js';

package/dist/tools/docx/builders/markdown-builder.d.ts

@@ -0,0 +1,2 @@
+import type { DocxBuildOptions } from '../types.js';
+export declare function createDocxFromMarkdown(markdown: string, options?: DocxBuildOptions): Promise<Buffer>;