@hcu-lab.me/mcp-device 1.0.5 → 1.0.7

package/dist/utils/feature-flags.js

@@ -1,215 +1,21 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { existsSync } from 'fs';
-import { CONFIG_FILE } from '../config.js';
-import { logger } from './logger.js';
 class FeatureFlagManager {
     constructor() {
         this.flags = {};
-        this.lastFetch = 0;
-        this.cacheMaxAge = 30 * 60 * 1000;
-        this.refreshInterval = null;
-        // Track fresh fetch status for A/B tests that need network flags
-        this.freshFetchPromise = null;
-        this.resolveFreshFetch = null;
-        this.loadedFromCache = false;
-        const configDir = path.dirname(CONFIG_FILE);
-        this.cachePath = path.join(configDir, 'feature-flags.json');
-        // Use production flags (v2 supports weighted variants)
-        this.flagUrl = process.env.DC_FLAG_URL ||
-            'https://desktopcommander.app/flags/v2/production.json';
-        // Set up promise for waiting on fresh fetch
-        this.freshFetchPromise = new Promise((resolve) => {
-            this.resolveFreshFetch = resolve;
-        });
     }
-    /**
-     * Initialize - load from cache and start background refresh
-     */
-    async initialize() {
-        try {
-            // Load from cache immediately (non-blocking)
-            await this.loadFromCache();
-            // Fetch in background (don't block startup)
-            this.fetchFlags().then(() => {
-                // Signal that fresh flags are now available
-                if (this.resolveFreshFetch) {
-                    this.resolveFreshFetch();
-                }
-            }).catch(err => {
-                logger.debug('Initial flag fetch failed:', err.message);
-                // Still resolve the promise so waiters don't hang forever
-                if (this.resolveFreshFetch) {
-                    this.resolveFreshFetch();
-                }
-            });
-            // Start periodic refresh every 5 minutes
-            this.refreshInterval = setInterval(() => {
-                this.fetchFlags().catch(err => {
-                    logger.debug('Periodic flag fetch failed:', err.message);
-                });
-            }, this.cacheMaxAge);
-            // Allow process to exit even if interval is pending
-            // This is critical for proper cleanup when MCP client disconnects
-            this.refreshInterval.unref();
-            logger.info(`Feature flags initialized (refresh every ${this.cacheMaxAge / 1000}s)`);
-        }
-        catch (error) {
-            logger.warning('Failed to initialize feature flags:', error);
-        }
-    }
-    /**
-     * Get a flag value
-     */
+    async initialize() { }
     get(flagName, defaultValue = false) {
         return this.flags[flagName] !== undefined ? this.flags[flagName] : defaultValue;
     }
-    /**
-     * Get all flags for debugging
-     */
     getAll() {
         return { ...this.flags };
     }
-    /**
-     * Manually refresh flags immediately (for testing)
-     */
     async refresh() {
-        try {
-            await this.fetchFlags();
-            return true;
-        }
-        catch (error) {
-            logger.error('Manual refresh failed:', error);
-            return false;
-        }
+        return true;
     }
-    /**
-     * Check if flags were loaded from cache (vs fresh fetch)
-     */
     wasLoadedFromCache() {
-        return this.loadedFromCache;
-    }
-    /**
-     * Wait for fresh flags to be fetched from network.
-     * Use this when you need to ensure flags are loaded before making decisions
-     * (e.g., A/B test assignments for new users who don't have a cache yet)
-     *
-     * Has a hard timeout to prevent blocking MCP startup if the fetch hangs.
-     * See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/465
-     */
-    async waitForFreshFlags() {
-        if (this.freshFetchPromise) {
-            let safetyTimeoutHandle;
-            try {
-                const safetyTimeout = new Promise((resolve) => {
-                    safetyTimeoutHandle = setTimeout(resolve, 5000);
-                });
-                await Promise.race([this.freshFetchPromise, safetyTimeout]);
-            }
-            finally {
-                if (safetyTimeoutHandle) {
-                    clearTimeout(safetyTimeoutHandle);
-                }
-            }
-        }
-    }
-    /**
-     * Load flags from local cache
-     */
-    async loadFromCache() {
-        try {
-            if (!existsSync(this.cachePath)) {
-                logger.debug('No feature flag cache found');
-                this.loadedFromCache = false;
-                return;
-            }
-            const data = await fs.readFile(this.cachePath, 'utf8');
-            const config = JSON.parse(data);
-            if (config.flags) {
-                this.flags = config.flags;
-                this.lastFetch = Date.now();
-                this.loadedFromCache = true;
-                logger.debug(`Loaded ${Object.keys(this.flags).length} feature flags from cache`);
-            }
-        }
-        catch (error) {
-            logger.warning('Failed to load feature flags from cache:', error);
-            this.loadedFromCache = false;
-        }
-    }
-    /**
-     * Fetch flags from remote URL
-     */
-    async fetchFlags() {
-        const FETCH_TIMEOUT_MS = 3000;
-        const controller = new AbortController();
-        const abortTimeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-        let hardTimeoutHandle;
-        try {
-            // Don't log here - runs async and can interfere with MCP clients
-            // Use Promise.race as a hard timeout safety net.
-            // On some platforms (Windows + Node 24 / undici 7.x), AbortController.abort()
-            // fails to interrupt an in-progress TCP connect — the fetch hangs until the
-            // OS-level TCP timeout (~30s on Windows). Promise.race guarantees we reject
-            // at the JS level regardless of AbortController behavior.
-            // See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/465
-            const fetchPromise = fetch(this.flagUrl, {
-                signal: controller.signal,
-                headers: {
-                    'Cache-Control': 'no-cache',
-                }
-            });
-            const hardTimeout = new Promise((_, reject) => hardTimeoutHandle = setTimeout(() => reject(new Error('Feature flags fetch timed out')), FETCH_TIMEOUT_MS));
-            const response = await Promise.race([fetchPromise, hardTimeout]);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            const config = await response.json();
-            // Update flags
-            if (config.flags) {
-                this.flags = config.flags;
-                this.lastFetch = Date.now();
-                // Save to cache (silently - don't log during async operations
-                // as it can interfere with MCP clients that close quickly)
-                await this.saveToCache(config);
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to fetch feature flags:', error.message);
-            // Continue with cached values
-        }
-        finally {
-            clearTimeout(abortTimeout);
-            if (hardTimeoutHandle) {
-                clearTimeout(hardTimeoutHandle);
-            }
-        }
-    }
-    /**
-     * Save flags to local cache
-     */
-    async saveToCache(config) {
-        try {
-            const configDir = path.dirname(this.cachePath);
-            if (!existsSync(configDir)) {
-                await fs.mkdir(configDir, { recursive: true });
-            }
-            await fs.writeFile(this.cachePath, JSON.stringify(config, null, 2), 'utf8');
-            // Don't log here - this runs async and can cause issues with MCP clients
-        }
-        catch (error) {
-            logger.warning('Failed to save feature flags to cache:', error);
-        }
-    }
-    /**
-     * Cleanup on shutdown
-     */
-    destroy() {
-        if (this.refreshInterval) {
-            clearInterval(this.refreshInterval);
-            this.refreshInterval = null;
-        }
+        return false;
     }
+    async waitForFreshFlags() { }
+    destroy() { }
 }
-// Export singleton instance
 export const featureFlagManager = new FeatureFlagManager();

package/dist/utils/files/docx.d.ts

@@ -5,10 +5,10 @@
  *
  * READ (default): Returns a text-bearing outline — skips shapes, drawings, SVG noise.
  *   Shows paragraphs with text, tables with cell content, style info, and image refs.
- *   Each element shows its raw XML tag context so Claude can target it for editing.
+ *   Each element shows its raw XML tag context so an agent can target it for editing.
  *
  * READ (with offset/length): Returns raw pretty-printed XML with line pagination,
- *   so Claude can drill into specific sections when the outline isn't enough.
+ *   so an agent can drill into specific sections when the outline isn't enough.
  *
  * EDIT (old_string/new_string): Find/replace on the pretty-printed XML, then
  *   compact and repack into valid DOCX. Works exactly like text file editing.

package/dist/utils/files/docx.js

@@ -5,10 +5,10 @@
  *
  * READ (default): Returns a text-bearing outline — skips shapes, drawings, SVG noise.
  *   Shows paragraphs with text, tables with cell content, style info, and image refs.
- *   Each element shows its raw XML tag context so Claude can target it for editing.
+ *   Each element shows its raw XML tag context so an agent can target it for editing.
  *
  * READ (with offset/length): Returns raw pretty-printed XML with line pagination,
- *   so Claude can drill into specific sections when the outline isn't enough.
+ *   so an agent can drill into specific sections when the outline isn't enough.
  *
  * EDIT (old_string/new_string): Find/replace on the pretty-printed XML, then
  *   compact and repack into valid DOCX. Works exactly like text file editing.

package/dist/utils/files/factory.js

@@ -5,6 +5,7 @@
  * Each handler implements canHandle() which can be sync (extension-based)
  * or async (content-based like BinaryFileHandler using isBinaryFile)
  */
+import fs from 'fs/promises';
 import { TextFileHandler } from './text.js';
 import { ImageFileHandler } from './image.js';
 import { BinaryFileHandler } from './binary.js';
@@ -86,6 +87,25 @@ export async function getFileHandler(filePath) {
     if (getImageHandler().canHandle(filePath)) {
         return getImageHandler();
     }
+    // UTF-16LE text contains many NUL bytes and generic binary sniffers
+    // often classify it as binary. A BOM is authoritative, so route it to the
+    // text handler before content-based binary detection.
+    try {
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const bom = Buffer.alloc(2);
+            const { bytesRead } = await fd.read(bom, 0, bom.length, 0);
+            if (bytesRead === 2 && bom[0] === 0xff && bom[1] === 0xfe) {
+                return getTextHandler();
+            }
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    catch {
+        // Preserve existing fallback behavior if the file cannot be sampled.
+    }
     // Check Binary (content-based, async via isBinaryFile)
     if (await getBinaryHandler().canHandle(filePath)) {
         return getBinaryHandler();

package/dist/utils/files/text.d.ts

@@ -19,6 +19,7 @@ import { FileHandler, ReadOptions, FileResult, FileInfo } from './base.js';
  */
 export declare class TextFileHandler implements FileHandler {
     canHandle(_path: string): boolean;
+    private detectTextEncoding;
     read(filePath: string, options?: ReadOptions): Promise<FileResult>;
     write(path: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
     getInfo(path: string): Promise<FileInfo>;

package/dist/utils/files/text.js

@@ -38,6 +38,17 @@ export class TextFileHandler {
         // The factory routes binary files to BinaryFileHandler before reaching here
         return true;
     }
+    async detectTextEncoding(filePath) {
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const bom = Buffer.alloc(2);
+            const { bytesRead } = await fd.read(bom, 0, bom.length, 0);
+            return bytesRead === 2 && bom[0] === 0xff && bom[1] === 0xfe ? 'utf16le' : 'utf8';
+        }
+        finally {
+            await fd.close();
+        }
+    }
     async read(filePath, options) {
         const offset = options?.offset ?? 0;
         const length = options?.length ?? 1000; // Default from config
@@ -69,7 +80,11 @@ export class TextFileHandler {
         // For text files that aren't too large, count lines
         if (stats.isFile() && stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
             try {
-                const content = await fs.readFile(path, 'utf8');
+                const encoding = await this.detectTextEncoding(path);
+                let content = await fs.readFile(path, encoding);
+                if (encoding === 'utf16le' && content.charCodeAt(0) === 0xfeff) {
+                    content = content.slice(1);
+                }
                 const lineCount = TextFileHandler.countLines(content);
                 info.metadata.lineCount = lineCount;
             }
@@ -100,11 +115,14 @@ export class TextFileHandler {
     /**
      * Get file line count (for files under size limit)
      */
-    async getFileLineCount(filePath, signal) {
+    async getFileLineCount(filePath, signal, encoding = 'utf8') {
         try {
             const stats = await fs.stat(filePath);
             if (stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
-                const content = await fs.readFile(filePath, { encoding: 'utf8', signal });
+                let content = await fs.readFile(filePath, { encoding, signal });
+                if (encoding === 'utf16le' && content.charCodeAt(0) === 0xfeff) {
+                    content = content.slice(1);
+                }
                 return TextFileHandler.countLines(content);
             }
         }
@@ -182,7 +200,16 @@ export class TextFileHandler {
     async readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true, signal) {
         const stats = await fs.stat(filePath);
         const fileSize = stats.size;
-        const totalLines = await this.getFileLineCount(filePath, signal);
+        const encoding = await this.detectTextEncoding(filePath);
+        const totalLines = await this.getFileLineCount(filePath, signal, encoding);
+        // UTF-16LE needs character-aware streaming. Skip the BOM and preserve
+        // the same line pagination/status semantics as UTF-8.
+        if (encoding === 'utf16le') {
+            if (offset < 0) {
+                return await this.readFromEndWithReadline(filePath, Math.abs(offset), mimeType, includeStatusMessage, totalLines, signal, 'utf16le', 2);
+            }
+            return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines, signal, 'utf16le', 2);
+        }
         // For negative offsets (tail behavior), use reverse reading
         if (offset < 0) {
             const requestedLines = Math.abs(offset);
@@ -252,9 +279,9 @@ export class TextFileHandler {
     /**
      * Read from end using readline with circular buffer
      */
-    async readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
+    async readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines, signal, encoding, start) {
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: createReadStream(filePath, { signal, encoding, start }),
             crlfDelay: Infinity
         });
         const buffer = new Array(requestedLines);
@@ -284,22 +311,28 @@ export class TextFileHandler {
     /**
      * Read from start/middle using readline
      */
-    async readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
+    async readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal, encoding, start) {
+        const stream = createReadStream(filePath, { signal, encoding, start });
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: stream,
             crlfDelay: Infinity
         });
         const result = [];
         let lineNumber = 0;
-        for await (const line of rl) {
-            if (lineNumber >= offset && result.length < length) {
-                result.push(line);
+        try {
+            for await (const line of rl) {
+                if (lineNumber >= offset && result.length < length) {
+                    result.push(line);
+                }
+                if (result.length >= length)
+                    break;
+                lineNumber++;
             }
-            if (result.length >= length)
-                break;
-            lineNumber++;
         }
-        rl.close();
+        finally {
+            rl.close();
+            stream.destroy();
+        }
         if (includeStatusMessage) {
             const statusMessage = this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false);
             const content = `${statusMessage}\n\n${result.join('\n')}`;
@@ -314,20 +347,26 @@ export class TextFileHandler {
      * Read from estimated byte position for very large files
      */
     async readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
-        // First, do a quick scan to estimate lines per byte
+        // First, do a quick scan to estimate lines per byte.
+        const sampleStream = createReadStream(filePath, { signal });
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: sampleStream,
             crlfDelay: Infinity
         });
         let sampleLines = 0;
         let bytesRead = 0;
-        for await (const line of rl) {
-            bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
-            sampleLines++;
-            if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
-                break;
+        try {
+            for await (const line of rl) {
+                bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+                sampleLines++;
+                if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
+                    break;
+            }
+        }
+        finally {
+            rl.close();
+            sampleStream.destroy();
         }
-        rl.close();
         if (sampleLines === 0) {
             return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, fileTotalLines, signal);
         }
@@ -345,19 +384,24 @@ export class TextFileHandler {
             });
             const result = [];
             let firstLineSkipped = false;
-            for await (const line of rl2) {
-                if (!firstLineSkipped && startPosition > 0) {
-                    firstLineSkipped = true;
-                    continue;
-                }
-                if (result.length < length) {
-                    result.push(line);
-                }
-                else {
-                    break;
+            try {
+                for await (const line of rl2) {
+                    if (!firstLineSkipped && startPosition > 0) {
+                        firstLineSkipped = true;
+                        continue;
+                    }
+                    if (result.length < length) {
+                        result.push(line);
+                    }
+                    else {
+                        break;
+                    }
                 }
             }
-            rl2.close();
+            finally {
+                rl2.close();
+                stream.destroy();
+            }
             const content = includeStatusMessage
                 ? `${this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false)}\n\n${result.join('\n')}`
                 : result.join('\n');

package/dist/utils/trackTools.js

@@ -13,8 +13,29 @@ export async function trackToolCall(toolName, args) {
     try {
         // Get current timestamp
         const timestamp = new Date().toISOString();
-        // Format the log entry
-        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${args ? `\t| Arguments: ${JSON.stringify(args)}` : ''}\n`;
+        // Remote MCP Device calls may contain commands, file contents, tokens or
+        // other secrets. Persist only bounded metadata in remote mode.
+        const remote = process.env.MCP_DEVICE_REMOTE === 'true';
+        let suffix = '';
+        if (args !== undefined) {
+            if (remote) {
+                let argBytes = 0;
+                let argCount = 0;
+                try {
+                    const serialized = JSON.stringify(args);
+                    argBytes = Buffer.byteLength(serialized || '', 'utf8');
+                    argCount = args && typeof args === 'object' && !Array.isArray(args)
+                        ? Object.keys(args).length
+                        : 1;
+                }
+                catch { /* metadata-only logging must never affect tool execution */ }
+                suffix = `\t| Args: count=${argCount} bytes=${argBytes}`;
+            }
+            else {
+                suffix = `\t| Arguments: ${JSON.stringify(args)}`;
+            }
+        }
+        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${suffix}\n`;
         // Check if file exists and get its size
         let fileSize = 0;
         try {

package/dist/utils/usageTracker.js

@@ -52,6 +52,8 @@ class UsageTracker {
      * keeps a saturated libuv threadpool from gating tool responses on every call.
      */
     async saveStats(stats) {
+        if (process.env.MCP_DEVICE_REMOTE === 'true')
+            return;
         await configManager.setValueNonBlocking('usageStats', stats);
     }
     /**
@@ -160,18 +162,6 @@ class UsageTracker {
         if (!feedbackEnabled) {
             return false;
         }
-        // Check if client is desktop-commander (disable for this client)
-        //return true;
-        try {
-            const { currentClient } = await import('../server.js');
-            if (currentClient?.name === 'desktop-commander') {
-                return false;
-            }
-        }
-        catch (error) {
-            // If we can't import server, continue with other checks
-            console.log('[FEEDBACK DEBUG] Could not check client name, continuing...');
-        }
         const stats = await this.getStats();
         // Don't prompt if feedback already given (check top-level config)
         const feedbackGiven = await configManager.getValue('feedbackGiven');
@@ -337,7 +327,6 @@ class UsageTracker {
         // within seconds, so when the flag is ON onboarding still fires on a
         // later call while the user is new. Deliberately no waiting here to keep
         // tool calls latency-free.
-        // See: https://github.com/wonderwhy-er/DesktopCommanderMCP/issues/538
         const onboardingEnabled = featureFlagManager.get('onboarding_injection', false);
         if (!onboardingEnabled) {
             return false;
@@ -351,17 +340,6 @@ class UsageTracker {
         if (global.disableOnboarding) {
             return false;
         }
-        // Check if client is desktop-commander (disable for this client)
-        try {
-            const { currentClient } = await import('../server.js');
-            if (currentClient?.name === 'desktop-commander') {
-                return false;
-            }
-        }
-        catch (error) {
-            // If we can't import server, continue with other checks
-            console.log('[ONBOARDING DEBUG] Could not check client name, continuing...');
-        }
         const stats = await this.getStats();
         const onboardingState = await this.getOnboardingState();
         const now = Date.now();

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.0.5";
+export declare const VERSION = "1.0.7";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.5';
+export const VERSION = '1.0.7';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hcu-lab.me/mcp-device",
-  "version": "1.0.5",
-  "description": "MCP Device securely connects a user-owned computer to an authenticated Model Context Protocol gateway.",
+  "version": "1.0.7",
+  "description": "MCP Device runtime.",
   "license": "MIT",
   "author": "Hirohimeow",
   "homepage": "https://github.com/Hiroshimeow/agent-mcp-device",
@@ -26,18 +26,18 @@
     "device:start": "tsx src/device/device.ts",
     "device:start:dev": "nodemon --watch src/device --exec tsx src/device/device.ts",
     "sync-version": "node scripts/sync-version.js",
-    "version": "node scripts/sync-version.js && git add server.json src/version.ts package-lock.json",
+    "version": "node scripts/sync-version.js && git add src/version.ts package-lock.json",
     "release": "node scripts/release.js patch",
     "release:minor": "node scripts/release.js minor",
     "release:major": "node scripts/release.js major",
     "bump": "node scripts/sync-version.js --bump",
     "bump:minor": "node scripts/sync-version.js --bump --minor",
     "bump:major": "node scripts/sync-version.js --bump --major",
-    "build": "shx rm -rf dist/remote-device && shx rm -f dist/device/desktop-commander-integration.js dist/device/desktop-commander-integration.d.ts dist/device/windows-dpapi.js dist/device/windows-dpapi.d.ts && tsc && shx chmod +x dist/*.js && shx mkdir -p dist/data && shx cp src/data/onboarding-prompts.json dist/data/ && node scripts/copy-official-ca.cjs && node scripts/build-ui-runtime.cjs",
+    "build": "shx rm -rf dist && tsc && shx chmod +x dist/*.js && shx cp src/device/update-helper.cjs dist/device/update-helper.cjs && shx mkdir -p dist/data && shx cp src/data/onboarding-prompts.json dist/data/ && node scripts/copy-official-ca.cjs && node scripts/build-ui-runtime.cjs",
     "watch": "tsc --watch",
     "start": "node dist/mcp-device.js",
     "start:debug": "node --inspect-brk=9229 dist/mcp-device.js",
-    "prepack": "node scripts/verify-production-trust.cjs && shx rm -rf dist/remote-device && shx rm -f dist/device/desktop-commander-integration.js dist/device/desktop-commander-integration.d.ts dist/device/windows-dpapi.js dist/device/windows-dpapi.d.ts dist/hcu-device.js dist/hcu-device.d.ts dist/track-installation.js dist/setup-claude-server.js dist/uninstall-claude-server.js dist/npm-scripts/setup.js dist/npm-scripts/setup.d.ts dist/npm-scripts/uninstall.js dist/npm-scripts/uninstall.d.ts dist/npm-scripts/verify-ripgrep.js dist/npm-scripts/verify-ripgrep.d.ts",
+    "prepack": "node scripts/verify-production-trust.cjs",
     "prepare": "npm run build",
     "clean": "shx rm -rf dist",
     "test": "npm run build && node test/run-all-tests.js",
@@ -57,7 +57,6 @@
     "mcp",
     "model-context-protocol",
     "terminal",
-    "claude",
     "ai",
     "command-line",
     "process-management",
@@ -73,7 +72,7 @@
     "file-operations"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "@opendocsg/pdf2md": "^0.2.2",
     "@tiptap/core": "^3.31.3",
     "@tiptap/extension-image": "^3.31.3",

package/dist/tools/feedback.d.ts

@@ -1,8 +0,0 @@
-import { ServerResult } from '../types.js';
-interface FeedbackParams {
-}
-/**
- * Open feedback form in browser with optional pre-filled data
- */
-export declare function giveFeedbackToDesktopCommander(params?: FeedbackParams): Promise<ServerResult>;
-export {};