@wonderwhy-er/desktop-commander 0.2.41 → 0.2.42

package/README.md

@@ -17,8 +17,6 @@ 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/
-
 ## 🖥️ Try the Desktop Commander App (Beta)
 
 **Want a better experience?** The Desktop Commander App gives you everything the MCP server does, plus:

package/dist/handlers/filesystem-handlers.js

@@ -1,4 +1,4 @@
-import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, getFileInfo, writePdf } from '../tools/filesystem.js';
+import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, getFileInfo, writePdf, getDefaultEditorMetadata } from '../tools/filesystem.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { configManager } from '../config-manager.js';
@@ -99,6 +99,8 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'unsupported',
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
                     content: pdfContent
                         .filter((item) => item.type === "text")
                         .map((item) => item.text)
@@ -108,8 +110,9 @@ export async function handleReadFile(args) {
         }
         // Handle image files
         if (fileResult.metadata?.isImage) {
-            // For image files, keep content payload text-only for broad host compatibility.
-            // The preview widget reads image bytes from structuredContent.
+            // Return the image bytes in the MCP content array so the host model can
+            // actually see the image. structuredContent additionally carries the bytes
+            // for the preview widget to render.
             const imageData = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('base64');
@@ -119,12 +122,19 @@ export async function handleReadFile(args) {
                     {
                         type: "text",
                         text: imageSummary
+                    },
+                    {
+                        type: "image",
+                        data: imageData,
+                        mimeType: fileResult.mimeType
                     }
                 ],
                 structuredContent: {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'image',
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
                     content: imageData,
                     imageData,
                     mimeType: fileResult.mimeType
@@ -145,6 +155,8 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType,
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
                     content: textContent,
                 },
             };
@@ -252,6 +264,8 @@ export async function handleWriteFile(args) {
                 fileName: path.basename(resolvedWritePath),
                 filePath: resolvedWritePath,
                 fileType: resolvePreviewFileType(resolvedWritePath),
+                sourceTool: 'write_file',
+                ...await getDefaultEditorMetadata(resolvedWritePath),
             },
         };
     }
@@ -293,6 +307,11 @@ export async function handleListDirectory(args) {
                 fileName: path.basename(resolvedPath),
                 filePath: resolvedPath,
                 fileType: 'directory',
+                sourceTool: 'list_directory',
+                // Carry the listing in structuredContent too. Chat reads the text
+                // content array, but structuredContent-only consumers (e.g. Cowork)
+                // render from here and would otherwise show an empty directory.
+                content: resultText,
             },
         };
     }

package/dist/server.d.ts

@@ -38,4 +38,5 @@ declare let currentClient: {
     name: string;
     version: string;
 };
-export { currentClient };
+declare let currentCallIsRemote: boolean;
+export { currentClient, currentCallIsRemote };

package/dist/server.js

@@ -21,8 +21,9 @@ 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, CONFIG_EDITOR_RESOURCE_URI, 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';
+import { shouldShowMcpUiPreviews } from './utils/mcp-ui-ab-test.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
 function deferLog(level, message) {
@@ -70,6 +71,21 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
 });
 // Store current client info (simple variable)
 let currentClient = { name: 'uninitialized', version: 'uninitialized' };
+// Tracks whether the in-flight tool call originated from a remote device.
+// Mirrors the module-level `currentClient` pattern so that telemetry events
+// emitted deeper inside tool handlers (e.g. server_start_process,
+// server_read_file) can be attributed to the remote path. The CallTool
+// handler sets this on every call (true when _meta.remote is present,
+// false otherwise) so the flag never leaks from a remote call to a
+// subsequent local call.
+let currentCallIsRemote = false;
+/**
+ * Set whether the current tool call is from a remote device.
+ * Called once per tool call by the CallTool handler.
+ */
+function setCurrentCallIsRemote(isRemote) {
+    currentCallIsRemote = isRemote;
+}
 /**
  * Unified way to update client information
  */
@@ -131,7 +147,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
     }
 });
 // Export current client info for access by other modules
-export { currentClient };
+export { currentClient, currentCallIsRemote };
 deferLog('info', 'Setting up request handlers...');
 /**
  * Check if a tool should be included based on current client
@@ -150,6 +166,7 @@ function shouldIncludeTool(toolName) {
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
         // logToStderr('debug', 'Generating tools list...');
+        const showMcpUiPreviews = await shouldShowMcpUiPreviews();
         // Build complete tools array
         const allTools = [
             // Configuration tools
@@ -169,7 +186,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(GetConfigArgsSchema),
-                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Get Configuration",
                     readOnlyHint: true,
@@ -262,7 +279,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Read File or URL",
                     readOnlyHint: true,
@@ -330,7 +347,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Write File",
                     readOnlyHint: false,
@@ -451,7 +468,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "List Directory Contents",
                     readOnlyHint: true,
@@ -710,7 +727,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(EditBlockArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Edit Block",
                     readOnlyHint: false,
@@ -1091,13 +1108,21 @@ import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
+    // Hoisted above the try so the finally block can read them when emitting the
+    // server_call_tool completion event (duration + status), even on the crash path.
+    let telemetryData = { tool_name: name };
+    let result;
+    let isError = false;
     try {
-        // Prepare telemetry data - add config key for set_config_value
-        const telemetryData = { tool_name: name };
-        // Extract metadata from _meta field if present
+        // telemetryData declared above; extract metadata from _meta field if present
         const metadata = request.params._meta;
+        // Reset remote attribution for every call so a prior remote call never
+        // leaks its flag onto a subsequent local call. Set to true only when
+        // this call carries the remote marker in _meta.
+        const isRemoteCall = !!(metadata && typeof metadata === 'object' && metadata.remote);
+        setCurrentCallIsRemote(isRemoteCall);
         if (metadata && typeof metadata === 'object') {
-            // add remote flag if present (convert to string for GA4)
+            // add remote flag if present (convert to string for telemetry)
             if (metadata.remote) {
                 telemetryData.remote = String(metadata.remote);
             }
@@ -1124,11 +1149,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 telemetryData.prompt_id = promptArgs.promptId;
             }
         }
-        capture_call_tool('server_call_tool', telemetryData);
         // Track tool call
         trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
-        let result;
+        // (result is declared above so the finally block can read execution status)
         switch (name) {
             // Config tools
             case "get_config":
@@ -1320,6 +1344,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
         const duration = Date.now() - startTime;
+        isError = !!result.isError;
         const EXCLUDED_TOOLS = [
             'get_recent_tool_calls',
             'track_ui_event'
@@ -1413,6 +1438,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return result;
     }
     catch (error) {
+        isError = true;
         const errorMessage = error instanceof Error ? error.message : String(error);
         // Track the failure
         await usageTracker.trackFailure(name);
@@ -1424,6 +1450,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             isError: true,
         };
     }
+    finally {
+        // Single tool-call telemetry event, fired AFTER execution so it can carry
+        // timing. In a finally so it still fires on the hard-crash path (the catch
+        // above). Only missed if a tool never returns or throws (a true hang).
+        capture_call_tool('server_call_tool', {
+            ...telemetryData,
+            duration_ms: Date.now() - startTime,
+            is_error: String(isError),
+        });
+    }
 });
 // Add no-op handlers so Visual Studio initialization succeeds
 server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({ resourceTemplates: [] }));

package/dist/setup-claude-server.js

@@ -10,10 +10,9 @@ import { version as nodeVersion } from 'process';
 import * as https from 'https';
 import { randomUUID } from 'crypto';
 
-// Google Analytics configuration
-const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
-const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';   // Replace with your GA4 API Secre
-const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+// Telemetry proxy configuration
+const TELEMETRY_PROXY_URL = 'https://telemetry.desktopcommander.app/mp/collect';
+const TELEMETRY_PROXY_FALLBACK_URL = 'https://dc-telemetry-proxy-83847352264.europe-west1.run.app/mp/collect';
 
 // Generate a unique anonymous ID using UUID - consistent with privacy policy
 let uniqueUserId = 'unknown';
@@ -302,11 +301,6 @@ async function enhancedGetTrackingProperties(additionalProps = {}) {
 async function trackEvent(eventName, additionalProps = {}) {
     const trackingStep = addSetupStep(`track_event_${eventName}`);
 
-    if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
-        updateSetupStep(trackingStep, 'skipped', new Error('GA not configured'));
-        return;
-    }
-
     // Add retry capability
     const maxRetries = 2;
     let attempt = 0;
@@ -319,7 +313,7 @@ async function trackEvent(eventName, additionalProps = {}) {
             // Get enriched properties
             const eventProperties = await enhancedGetTrackingProperties(additionalProps);
 
-            // Prepare GA4 payload
+            // Prepare telemetry payload
             const payload = {
                 client_id: uniqueUserId,
                 non_personalized_ads: false,
@@ -330,7 +324,7 @@ async function trackEvent(eventName, additionalProps = {}) {
                 }]
             };
 
-            // Send to Google Analytics
+            // Send to telemetry proxy
             const postData = JSON.stringify(payload);
             
             const options = {
@@ -341,44 +335,8 @@ async function trackEvent(eventName, additionalProps = {}) {
                 }
             };
 
-            const result = await new Promise((resolve, reject) => {
-                const req = https.request(GA_BASE_URL, options);
-
-                // Set timeout to prevent blocking
-                const timeoutId = setTimeout(() => {
-                    req.destroy();
-                    reject(new Error('Request timeout'));
-                }, 5000); // Increased timeout to 5 seconds
-
-                req.on('error', (error) => {
-                    clearTimeout(timeoutId);
-                    reject(error);
-                });
-
-                req.on('response', (res) => {
-                    clearTimeout(timeoutId);
-                    let data = '';
-
-                    res.on('data', (chunk) => {
-                        data += chunk;
-                    });
-
-                    res.on('error', (error) => {
-                        reject(error);
-                    });
-
-                    res.on('end', () => {
-                        if (res.statusCode >= 200 && res.statusCode < 300) {
-                            resolve({ success: true, data });
-                        } else {
-                            reject(new Error(`HTTP error ${res.statusCode}: ${data}`));
-                        }
-                    });
-                });
-
-                req.write(postData);
-                req.end();
-            });
+            const result = await postTelemetryPayload(postData, options);
+            if (!result.success) throw new Error('Telemetry proxy request failed');
 
             updateSetupStep(trackingStep, 'completed');
             return result;
@@ -397,6 +355,54 @@ async function trackEvent(eventName, additionalProps = {}) {
     return false;
 }
 
+async function postTelemetryPayload(postData, options) {
+    for (const endpoint of [TELEMETRY_PROXY_URL, TELEMETRY_PROXY_FALLBACK_URL]) {
+        const result = await new Promise((resolve) => {
+            let settled = false;
+            let timeoutId;
+            const finish = (result) => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeoutId);
+                resolve(result);
+            };
+            const req = https.request(endpoint, options);
+
+            timeoutId = setTimeout(() => {
+                req.destroy();
+                finish({ success: false, data: '' });
+            }, 5000);
+
+            req.on('error', () => {
+                finish({ success: false, data: '' });
+            });
+
+            req.on('response', (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('error', () => {
+                    finish({ success: false, data: '' });
+                });
+                res.on('end', () => {
+                    finish({ success: res.statusCode >= 200 && res.statusCode < 300, data });
+                });
+                res.on('close', () => {
+                    finish({ success: false, data: '' });
+                });
+            });
+
+            req.write(postData);
+            req.end();
+        });
+
+        if (result.success) return result;
+    }
+
+    return { success: false, data: '' };
+}
+
 // Ensure tracking completes before process exits
 async function ensureTrackingCompleted(eventName, additionalProps = {}, timeoutMs = 6000) {
     return new Promise(async (resolve) => {
@@ -933,4 +939,4 @@ if (process.argv.length >= 2 && process.argv[1] === fileURLToPath(import.meta.ur
             process.exit(1);
         }, 1000);
     });
-}
+}

package/dist/terminal-manager.js

@@ -4,6 +4,34 @@ import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
 import { capture } from "./utils/capture.js";
 import { analyzeProcessState } from './utils/process-detection.js';
+/**
+ * Standard Windows PATHEXT value, used to repair a corrupted PATHEXT before
+ * spawning child shells.
+ *
+ * On some Windows Claude Desktop / DXT launches the server process inherits a
+ * broken PATHEXT (observed as ".CPL" only). Because we build the child env from
+ * { ...process.env }, that broken value would propagate into every spawned
+ * shell, stripping ".EXE" and breaking resolution of git / node / python / rg /
+ * etc. (and even full-path .exe invocations under PowerShell). See issue #481.
+ */
+const STANDARD_PATHEXT = '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC';
+/**
+ * Return a healthy PATHEXT for spawned Windows shells.
+ * - Unset           -> use the standard list.
+ * - Missing ".EXE"  -> corrupted; merge the standard list with whatever was
+ *                      present (preserves any extra extensions, order-stable).
+ * - Otherwise       -> leave the inherited value untouched.
+ */
+function getRepairedPathExt() {
+    const current = process.env.PATHEXT;
+    if (!current)
+        return STANDARD_PATHEXT;
+    const exts = current.split(';').map(e => e.trim().toUpperCase()).filter(Boolean);
+    if (!exts.includes('.EXE')) {
+        return [...new Set([...STANDARD_PATHEXT.split(';'), ...exts])].join(';');
+    }
+    return current;
+}
 /**
  * Get the appropriate spawn configuration for a given shell
  * This handles login shell flags for different shell types
@@ -39,6 +67,7 @@ function getShellSpawnArgs(shellPath, command) {
         return {
             executable: shellPath,
             args: ['/c', command],
+            windowsVerbatim: true,
             useShellOption: false
         };
     }
@@ -143,6 +172,23 @@ export class TerminalManager {
                 windowsHide: true // Prevent visible console windows on Windows
             };
         }
+        // Repair PATHEXT on Windows before spawning. On some Windows DXT launches
+        // the server process inherits a corrupted PATHEXT (e.g. ".CPL"), which we
+        // would otherwise propagate via { ...process.env } and break command
+        // resolution (git, node, python, rg, ...) in the spawned shell. See #481.
+        if (process.platform === 'win32' && spawnOptions.env) {
+            spawnOptions.env.PATHEXT = getRepairedPathExt();
+        }
+        // On Windows, when we invoke cmd.exe directly and pass the user's command as a
+        // single argument, Node/libuv applies MSVCRT-style quoting that escapes embedded
+        // double quotes as \" . cmd.exe does not understand that escaping, so any command
+        // containing quotes (e.g. a quoted path with spaces like "C:\Program Files\app.exe")
+        // is corrupted before the shell ever parses it. Passing arguments verbatim lets
+        // cmd handle its own quoting. Scoped to shells that set windowsVerbatim (cmd only)
+        // because PowerShell/pwsh have different quote rules and must NOT use verbatim.
+        if (process.platform === 'win32' && spawnConfig.windowsVerbatim) {
+            spawnOptions.windowsVerbatimArguments = true;
+        }
         // Spawn the process with appropriate arguments
         const childProcess = spawn(spawnConfig.executable, spawnConfig.args, spawnOptions);
         let output = '';

package/dist/tools/edit.js

@@ -14,7 +14,7 @@
  * 2. Make this file a thin dispatch layer that routes to appropriate FileHandler
  * 3. Unify the editRange() signature to handle both text search/replace and structured edits
  */
-import { writeFile, readFileInternal, validatePath } from './filesystem.js';
+import { getDefaultEditorMetadata, writeFile, readFileInternal, validatePath } from './filesystem.js';
 import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { createErrorResponse } from '../error-handlers.js';
@@ -180,6 +180,8 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
                 fileName: path.basename(resolvedEditPath),
                 filePath: resolvedEditPath,
                 fileType: resolvePreviewFileType(resolvedEditPath),
+                sourceTool: 'edit_block',
+                ...await getDefaultEditorMetadata(resolvedEditPath),
             },
         };
     }
@@ -368,6 +370,8 @@ export async function handleEditBlock(args) {
                         fileName: path.basename(resolvedRangePath),
                         filePath: resolvedRangePath,
                         fileType: resolvePreviewFileType(resolvedRangePath),
+                        sourceTool: 'edit_block',
+                        ...await getDefaultEditorMetadata(resolvedRangePath),
                     },
                 };
             }
@@ -403,6 +407,8 @@ export async function handleEditBlock(args) {
                         fileName: path.basename(resolvedEditRangePath),
                         filePath: resolvedEditRangePath,
                         fileType: resolvePreviewFileType(resolvedEditRangePath),
+                        sourceTool: 'edit_block',
+                        ...await getDefaultEditorMetadata(resolvedEditRangePath),
                     },
                 };
             }

package/dist/tools/filesystem.d.ts

@@ -71,3 +71,8 @@ export declare function getFileInfo(filePath: string): Promise<Record<string, an
  * @param options Options for PDF generation or modification. For modification, can include `sourcePdf`.
  */
 export declare function writePdf(filePath: string, content: string | PdfOperations[], outputPath?: string, options?: any): Promise<void>;
+type DefaultEditorMetadata = {
+    defaultEditorName?: string;
+    defaultEditorPath?: string;
+};
+export declare function getDefaultEditorMetadata(filePath: string): Promise<DefaultEditorMetadata>;

package/dist/tools/filesystem.js

@@ -2,6 +2,8 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { capture } from '../utils/capture.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
@@ -887,3 +889,44 @@ export async function writePdf(filePath, content, outputPath, options = {}) {
         throw new Error('Invalid content type for writePdf. Expected string (markdown) or array of operations.');
     }
 }
+const execFileAsync = promisify(execFile);
+const DEFAULT_EDITOR_NEGATIVE_CACHE_MS = 5 * 60 * 1000;
+const defaultEditorCache = new Map();
+function escapeAppleScriptString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export async function getDefaultEditorMetadata(filePath) {
+    if (os.platform() !== 'darwin') {
+        return {};
+    }
+    let cacheKey = '';
+    try {
+        const extension = path.extname(filePath).toLowerCase();
+        cacheKey = extension || path.basename(filePath).toLowerCase();
+        const cached = defaultEditorCache.get(cacheKey);
+        if (cached) {
+            if (!cached.expiresAt || cached.expiresAt > Date.now()) {
+                return cached.metadata;
+            }
+            defaultEditorCache.delete(cacheKey);
+        }
+        const script = `set appAlias to default application of (info for POSIX file "${escapeAppleScriptString(filePath)}")\nreturn (name of (info for appAlias)) & linefeed & POSIX path of appAlias`;
+        const { stdout } = await execFileAsync('osascript', ['-e', script], { timeout: 12000 });
+        const lines = stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+        const defaultEditorName = lines[lines.length - 2]?.replace(/\.app$/i, '') ?? '';
+        const defaultEditorPath = lines[lines.length - 1] ?? '';
+        if (defaultEditorName && defaultEditorPath.startsWith('/')) {
+            const metadata = { defaultEditorName, defaultEditorPath };
+            defaultEditorCache.set(cacheKey, { metadata });
+            return metadata;
+        }
+        defaultEditorCache.set(cacheKey, { metadata: {}, expiresAt: Date.now() + DEFAULT_EDITOR_NEGATIVE_CACHE_MS });
+    }
+    catch {
+        if (cacheKey) {
+            defaultEditorCache.set(cacheKey, { metadata: {}, expiresAt: Date.now() + DEFAULT_EDITOR_NEGATIVE_CACHE_MS });
+        }
+        // Generic UI fallback is good enough if detection fails.
+    }
+    return {};
+}

package/dist/tools/pdf/markdown.d.ts

@@ -1,5 +1,17 @@
 import type { PageRange } from './lib/pdf2md.js';
 import { PdfParseResult } from './lib/pdf2md.js';
+interface CachedPuppeteerChrome {
+    executablePath: string;
+}
+/**
+ * Find Chrome in puppeteer's cache directory
+ * Returns the executable path if found, undefined otherwise
+ */
+export declare function findPuppeteerChrome(cacheDir?: string): CachedPuppeteerChrome | undefined;
+/**
+ * Remove stale Puppeteer Chrome builds while preserving the active build.
+ */
+export declare function pruneOldPuppeteerChromeBuilds(activeExecutablePath: string, cacheDir?: string): Promise<void>;
 /**
  * Preemptively ensure Chrome is available for PDF generation.
  * Call this at server startup to trigger download in background if needed.
@@ -11,3 +23,4 @@ export declare function ensureChromeAvailable(): void;
  */
 export declare function parsePdfToMarkdown(source: string, pageNumbers?: number[] | PageRange): Promise<PdfParseResult>;
 export declare function parseMarkdownToPdf(markdown: string, options?: any): Promise<Buffer>;
+export {};