@wonderwhy-er/desktop-commander 0.2.40 → 0.2.42

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';
@@ -220,6 +222,38 @@ export async function validatePath(requestedPath) {
                 });
                 throw new Error(`Failed to resolve symlink for path: ${absoluteOriginal}. Error: ${err.message}`);
             }
+            // SECURITY FIX: When the full path doesn't exist (e.g., writing a new file),
+            // resolve the parent directory to detect symlinks in the path chain.
+            // Without this, an attacker could create a symlink inside an allowed directory
+            // pointing to a restricted location, then write to a non-existent file through
+            // that symlink — bypassing the directory restriction check.
+            try {
+                const parentDir = path.dirname(absoluteOriginal);
+                const resolvedParent = await fs.realpath(parentDir, { encoding: 'utf8' });
+                const basename = path.basename(absoluteOriginal);
+                resolvedRealPath = path.join(resolvedParent, basename);
+            }
+            catch {
+                // Parent also doesn't exist — walk up the tree to find
+                // the deepest existing ancestor and resolve it
+                let current = absoluteOriginal;
+                let remaining = [];
+                while (true) {
+                    const parent = path.dirname(current);
+                    if (parent === current)
+                        break; // reached filesystem root
+                    remaining.unshift(path.basename(current));
+                    current = parent;
+                    try {
+                        const resolvedAncestor = await fs.realpath(current, { encoding: 'utf8' });
+                        resolvedRealPath = path.join(resolvedAncestor, ...remaining);
+                        break;
+                    }
+                    catch {
+                        // keep walking up
+                    }
+                }
+            }
         }
         const pathForNextCheck = resolvedRealPath ?? absoluteOriginal;
         // Check if path is allowed
@@ -230,25 +264,25 @@ export async function validatePath(requestedPath) {
             });
             throw new Error(`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
         }
+        // SECURITY: Always return the resolved path (with symlinks resolved) so that
+        // all subsequent file operations (read, write, mkdir, etc.) operate on the
+        // canonical target, not on a symlink that could point outside allowed directories.
+        // pathForNextCheck already holds resolvedRealPath ?? absoluteOriginal from above.
         // Check if path exists
         try {
             // fs.stat() will automatically follow symlinks, so we get existence info
-            const stats = await fs.stat(absoluteOriginal);
-            // If path exists, resolve any symlinks
-            if (resolvedRealPath) {
-                return resolvedRealPath;
-            }
-            return absoluteOriginal;
+            await fs.stat(pathForNextCheck);
+            return pathForNextCheck;
         }
         catch (error) {
             // Path doesn't exist - validate parent directories
-            if (await validateParentDirectories(absoluteOriginal)) {
-                // Return the path if a valid parent exists
+            if (await validateParentDirectories(pathForNextCheck)) {
+                // Return the resolved path if a valid parent exists
                 // This will be used for folder creation and many other file operations
-                return absoluteOriginal;
+                return pathForNextCheck;
             }
-            // If no valid parent found, return the absolute path anyway
-            return absoluteOriginal;
+            // If no valid parent found, return the resolved path anyway
+            return pathForNextCheck;
         }
     };
     // Execute with timeout
@@ -573,9 +607,11 @@ export async function listDirectory(dirPath, depth = 2) {
         catch (error) {
             const err = error;
             const displayPath = relativePath || path.basename(currentPath);
-            // Keep [DENIED] prefix so UI parser regex still matches.
-            // Append a hint for permission/timeout errors so user gets context.
-            if (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'ETIMEDOUT') {
+            // Distinguish "not found" from "permission denied" so AI and UI get accurate info.
+            if (err.code === 'ENOENT') {
+                results.push(`[NOT_FOUND] ${displayPath} — path does not exist`);
+            }
+            else if (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'ETIMEDOUT') {
                 results.push(`[DENIED] ${displayPath} — not accessible (permission denied, cloud-only file, or Full Disk Access not granted)`);
             }
             else {
@@ -853,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 {};

package/dist/tools/pdf/markdown.js

@@ -1,48 +1,76 @@
 import fs from 'fs/promises';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { mdToPdf } from 'md-to-pdf';
 import { pdf2md } from './lib/pdf2md.js';
+import { CONFIG_FILE } from '../../config.js';
 const isUrl = (source) => source.startsWith('http://') || source.startsWith('https://');
 // Cached Chrome path to avoid repeated lookups
 let cachedChromePath = null; // null = not checked yet
 let chromeCheckPromise = null;
 /**
- * Get the puppeteer cache directory
+ * Get Desktop Commander's private Puppeteer cache directory.
  */
 function getPuppeteerCacheDir() {
-    return join(homedir(), '.cache', 'puppeteer');
+    return join(dirname(CONFIG_FILE), 'puppeteer-cache');
+}
+/**
+ * Get the cache path where Puppeteer stores Chrome for Testing builds.
+ */
+function getPuppeteerChromeDir(cacheDir = getPuppeteerCacheDir()) {
+    return join(cacheDir, 'chrome');
+}
+/**
+ * Find the platform-specific executable within a cached Chrome build directory.
+ */
+function getChromeExecutablePath(chromeDir, version) {
+    const chromePath = process.platform === 'win32'
+        ? join(chromeDir, version, 'chrome-win64', 'chrome.exe')
+        : process.platform === 'darwin'
+            ? join(chromeDir, version, 'chrome-mac-x64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing')
+            : join(chromeDir, version, 'chrome-linux64', 'chrome');
+    if (existsSync(chromePath)) {
+        return chromePath;
+    }
+    // Also check for arm64 mac
+    if (process.platform === 'darwin') {
+        const armPath = join(chromeDir, version, 'chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+        if (existsSync(armPath)) {
+            return armPath;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the cached Chrome build directory that owns an executable path.
+ */
+function getCachedChromeBuildDir(chromeDir, executablePath) {
+    const relativePath = relative(chromeDir, executablePath);
+    if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        return undefined;
+    }
+    const [buildDir] = relativePath.split(sep);
+    return buildDir ? join(chromeDir, buildDir) : undefined;
 }
 /**
  * Find Chrome in puppeteer's cache directory
  * Returns the executable path if found, undefined otherwise
  */
-function findPuppeteerChrome() {
-    const cacheDir = getPuppeteerCacheDir();
-    const chromeDir = join(cacheDir, 'chrome');
+export function findPuppeteerChrome(cacheDir = getPuppeteerCacheDir()) {
+    const chromeDir = getPuppeteerChromeDir(cacheDir);
     if (!existsSync(chromeDir)) {
         return undefined;
     }
     try {
         // Look for chrome directories (e.g., win64-143.0.7499.169)
-        const { readdirSync } = require('fs');
-        const versions = readdirSync(chromeDir);
+        const versions = readdirSync(chromeDir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name)
+            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
         for (const version of versions) {
-            const chromePath = process.platform === 'win32'
-                ? join(chromeDir, version, 'chrome-win64', 'chrome.exe')
-                : process.platform === 'darwin'
-                    ? join(chromeDir, version, 'chrome-mac-x64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing')
-                    : join(chromeDir, version, 'chrome-linux64', 'chrome');
-            if (existsSync(chromePath)) {
-                return chromePath;
-            }
-            // Also check for arm64 mac
-            if (process.platform === 'darwin') {
-                const armPath = join(chromeDir, version, 'chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
-                if (existsSync(armPath)) {
-                    return armPath;
-                }
+            const executablePath = getChromeExecutablePath(chromeDir, version);
+            if (executablePath) {
+                return { executablePath };
             }
         }
     }
@@ -51,6 +79,37 @@ function findPuppeteerChrome() {
     }
     return undefined;
 }
+/**
+ * Remove stale Puppeteer Chrome builds while preserving the active build.
+ */
+export async function pruneOldPuppeteerChromeBuilds(activeExecutablePath, cacheDir = getPuppeteerCacheDir()) {
+    const chromeDir = getPuppeteerChromeDir(cacheDir);
+    const activeBuildDir = getCachedChromeBuildDir(chromeDir, activeExecutablePath);
+    if (!activeBuildDir) {
+        return;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(chromeDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    await Promise.all(entries
+        .filter(entry => entry.isDirectory())
+        .map(async (entry) => {
+        const buildDir = join(chromeDir, entry.name);
+        if (resolve(buildDir) === resolve(activeBuildDir)) {
+            return;
+        }
+        try {
+            await fs.rm(buildDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.error(`Failed to remove old Chrome cache build at ${buildDir}:`, error);
+        }
+    }));
+}
 /**
  * Find system-installed Chrome/Chromium browser
  * Returns the executable path if found, undefined otherwise
@@ -91,6 +150,7 @@ async function installChrome() {
     const platform = detectBrowserPlatform();
     const buildId = await resolveBuildId(Browser.CHROME, platform, 'stable');
     console.error('Downloading Chrome for PDF generation (this may take a few minutes)...');
+    await fs.mkdir(cacheDir, { recursive: true });
     const installedBrowser = await install({
         browser: Browser.CHROME,
         buildId,
@@ -101,7 +161,9 @@ async function installChrome() {
         },
     });
     console.error('\nChrome download complete.');
-    return installedBrowser.executablePath;
+    return {
+        executablePath: installedBrowser.executablePath,
+    };
 }
 /**
  * Find or install Chrome for PDF generation
@@ -122,8 +184,9 @@ async function getChromePath() {
         // 1. Check puppeteer cache first (exact compatible version)
         const cachedChrome = findPuppeteerChrome();
         if (cachedChrome) {
-            cachedChromePath = cachedChrome;
-            return cachedChrome;
+            await pruneOldPuppeteerChromeBuilds(cachedChrome.executablePath);
+            cachedChromePath = cachedChrome.executablePath;
+            return cachedChrome.executablePath;
         }
         // 2. Check system Chrome
         const systemChrome = findSystemChrome();
@@ -134,8 +197,9 @@ async function getChromePath() {
         // 3. Install Chrome as last resort
         try {
             const installedChrome = await installChrome();
-            cachedChromePath = installedChrome;
-            return installedChrome;
+            await pruneOldPuppeteerChromeBuilds(installedChrome.executablePath);
+            cachedChromePath = installedChrome.executablePath;
+            return installedChrome.executablePath;
         }
         catch (error) {
             console.error('Failed to install Chrome:', error);

package/dist/track-installation.js

@@ -73,10 +73,9 @@ async function getClientId() {
     }
 }
 
-// Google Analytics configuration (same as setup script)
-const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L';
-const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';
-const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+// Telemetry proxy configuration (same as setup script)
+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';
 
 /**
  * Detect installation source from environment and process context
@@ -267,18 +266,13 @@ async function detectInstallationSource() {
 }
 
 /**
- * Send installation tracking to analytics
+ * Send installation tracking to telemetry proxy
  */
 async function trackInstallation(installationData) {
-    if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
-        debug('Analytics not configured, skipping tracking');
-        return;
-    }
-
     try {
         const uniqueUserId = await getClientId();
         log("user id", uniqueUserId)
-        // Prepare GA4 payload
+        // Prepare telemetry payload
         const payload = {
             client_id: uniqueUserId,
             non_personalized_ads: false,
@@ -308,33 +302,11 @@ async function trackInstallation(installationData) {
             }
         };
 
-        await new Promise((resolve, reject) => {
-            const req = https.request(GA_BASE_URL, options);
-            
-            const timeoutId = setTimeout(() => {
-                req.destroy();
-                reject(new Error('Request timeout'));
-            }, 5000);
-
-            req.on('error', (error) => {
-                clearTimeout(timeoutId);
-                debug(`Analytics error: ${error.message}`);
-                resolve(); // Don't fail installation on analytics error
-            });
-
-            req.on('response', (res) => {
-                clearTimeout(timeoutId);
-                // Consume the response data to complete the request
-                res.on('data', () => {}); // Ignore response data
-                res.on('end', () => {
-                    log(`Installation tracked: ${installationData.source}`);
-                    resolve();
-                });
-            });
-
-            req.write(postData);
-            req.end();
-        });
+        const sent = await postTelemetryPayload(TELEMETRY_PROXY_URL, postData, options);
+        if (!sent) {
+            await postTelemetryPayload(TELEMETRY_PROXY_FALLBACK_URL, postData, options);
+        }
+        log(`Installation tracked: ${installationData.source}`);
 
     } catch (error) {
         debug(`Failed to track installation: ${error.message}`);
@@ -342,6 +314,53 @@ async function trackInstallation(installationData) {
     }
 }
 
+// TODO(dedup): postTelemetryPayload is copy-pasted across setup/uninstall/track
+// scripts + a variant in src/utils/capture.ts. Consolidate into one shared module.
+// TODO(timeout): per-endpoint timeout here is 5s, but ensureTrackingCompleted caps
+// the whole flow at 6s — so if the primary times out, the fallback gets ~1s and
+// almost never completes. Lower per-endpoint timeout (capture.ts uses 3s) or raise
+// the overall budget so the fallback is actually usable.
+async function postTelemetryPayload(endpoint, postData, options) {
+    return 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(false);
+        }, 5000);
+
+        req.on('error', (error) => {
+            debug(`Telemetry error: ${error.message}`);
+            finish(false);
+        });
+
+        req.on('response', (res) => {
+            res.on('data', () => {});
+            res.on('error', (error) => {
+                debug(`Telemetry response error: ${error.message}`);
+                finish(false);
+            });
+            res.on('end', () => {
+                finish(res.statusCode >= 200 && res.statusCode < 300);
+            });
+            res.on('close', () => {
+                finish(false);
+            });
+        });
+
+        req.write(postData);
+        req.end();
+    });
+}
+
 /**
  * Main execution
  */

package/dist/types.d.ts

@@ -65,6 +65,10 @@ export interface FilePreviewStructuredContent {
     fileName: string;
     filePath: string;
     fileType: PreviewFileType;
+    sourceTool?: 'read_file' | 'write_file' | 'edit_block';
+    defaultEditorName?: string;
+    defaultEditorPath?: string;
+    content?: string;
     imageData?: string;
     mimeType?: string;
 }

package/dist/ui/contracts.d.ts

@@ -11,4 +11,4 @@ export interface UiToolMeta extends Record<string, unknown> {
     };
     'openai/widgetAccessible'?: boolean;
 }
-export declare function buildUiToolMeta(resourceUri: string, widgetAccessible?: boolean): UiToolMeta;
+export declare function buildUiToolMeta(resourceUri: string, widgetAccessible?: boolean, showMcpUiPreviews?: boolean): UiToolMeta | undefined;

package/dist/ui/contracts.js

@@ -3,7 +3,10 @@
  */
 export const FILE_PREVIEW_RESOURCE_URI = 'ui://desktop-commander/file-preview';
 export const CONFIG_EDITOR_RESOURCE_URI = 'ui://desktop-commander/config-editor';
-export function buildUiToolMeta(resourceUri, widgetAccessible = false) {
+export function buildUiToolMeta(resourceUri, widgetAccessible = false, showMcpUiPreviews = true) {
+    if (!showMcpUiPreviews) {
+        return undefined;
+    }
     const meta = {
         'ui/resourceUri': resourceUri,
         'openai/outputTemplate': resourceUri,