@wonderwhy-er/desktop-commander 0.2.41 → 0.2.42

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,9 @@ 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,