@wonderwhy-er/desktop-commander 0.2.37 → 0.2.39

package/dist/tools/edit.js

@@ -23,6 +23,8 @@ import path from 'path';
 import { detectLineEnding, normalizeLineEndings } from '../utils/lineEndingHandler.js';
 import { configManager } from '../config-manager.js';
 import { fuzzySearchLogger } from '../utils/fuzzySearchLogger.js';
+import { resolvePreviewFileType } from '../ui/file-preview/shared/preview-file-types.js';
+import { resolveAbsolutePath } from '../handlers/filesystem-handlers.js';
 /**
  * Threshold for fuzzy matching - similarity must be at least this value to be considered
  * (0-1 scale where 1 is perfect match and 0 is completely different)
@@ -155,11 +157,30 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
         }
         await writeFile(filePath, newContent);
         capture('server_edit_block_exact_success', { fileExtension: fileExtension, expectedReplacements, hasWarning: warningMessage !== "" });
+        const resolvedEditPath = resolveAbsolutePath(filePath);
+        // Show a partial preview centered on the edited area
+        const newLines = newContent.split('\n');
+        const totalLines = newLines.length;
+        const changePos = content.indexOf(normalizedSearch);
+        const changeStartLine = changePos >= 0 ? newContent.substring(0, changePos).split('\n').length - 1 : 0;
+        const changeLineCount = block.replace.split('\n').length;
+        const contextLines = 10;
+        const previewStart = Math.max(0, changeStartLine - contextLines);
+        const previewEnd = Math.min(totalLines, changeStartLine + changeLineCount + contextLines);
+        const previewContent = newLines.slice(previewStart, previewEnd).join('\n');
+        const previewLineCount = previewEnd - previewStart;
+        const remaining = totalLines - previewEnd;
+        const statusLine = `[Reading ${previewLineCount} lines from ${previewStart === 0 ? 'start' : `line ${previewStart}`} (total: ${totalLines} lines, ${remaining} remaining)]\n\n`;
         return {
             content: [{
                     type: "text",
-                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}${warningMessage}`
+                    text: `${statusLine}${previewContent}`
                 }],
+            structuredContent: {
+                fileName: path.basename(resolvedEditPath),
+                filePath: resolvedEditPath,
+                fileType: resolvePreviewFileType(resolvedEditPath),
+            },
         };
     }
     // If exact match found but count doesn't match expected, inform the user
@@ -337,11 +358,17 @@ export async function handleEditBlock(args) {
             try {
                 // parsed.range is guaranteed non-empty string by hasRange check above
                 await handler.editRange(validatedPath, parsed.range, content, parsed.options);
+                const resolvedRangePath = resolveAbsolutePath(parsed.file_path);
                 return {
                     content: [{
                             type: "text",
                             text: `Successfully updated range ${parsed.range} in ${parsed.file_path}`
                         }],
+                    structuredContent: {
+                        fileName: path.basename(resolvedRangePath),
+                        filePath: resolvedRangePath,
+                        fileType: resolvePreviewFileType(resolvedRangePath),
+                    },
                 };
             }
             catch (error) {
@@ -366,11 +393,17 @@ export async function handleEditBlock(args) {
                 expected_replacements: parsed.expected_replacements,
             });
             if (result.success) {
+                const resolvedEditRangePath = resolveAbsolutePath(parsed.file_path);
                 return {
                     content: [{
                             type: "text",
                             text: `Successfully applied ${result.editsApplied} edit(s) to ${parsed.file_path}`
                         }],
+                    structuredContent: {
+                        fileName: path.basename(resolvedEditRangePath),
+                        filePath: resolvedEditRangePath,
+                        fileType: resolvePreviewFileType(resolvedEditRangePath),
+                    },
                 };
             }
             const errorMsg = result.errors?.map(e => e.error).join('; ') || 'Unknown error';

package/dist/tools/filesystem.js

@@ -46,6 +46,45 @@ async function getDefaultReadLength() {
     const config = await configManager.getConfig();
     return config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
 }
+/**
+ * Returns a helpful error message when a file operation fails with a permission
+ * or timeout error.
+ *
+ * Lists all common causes without path-based detection — the AI receiving this
+ * error should inspect the path and inform the user which cause is most likely
+ * (e.g. cloud storage folder, network drive, system file, locked file, etc.)
+ */
+function buildPermissionError(filePath, errCode) {
+    const isMac = process.platform === 'darwin';
+    const isTimeout = errCode === 'ETIMEDOUT';
+    const lines = [
+        `Cannot read file — ${isTimeout ? 'operation timed out' : 'permission denied'} (${errCode}).`,
+        `Path: ${filePath}`,
+        ``,
+        `[AI: based on the path above, determine which cause is most likely and explain it to the user.]`,
+        ``,
+        `Possible causes and fixes:`,
+        `  1. File is in cloud storage (Google Drive / iCloud / Dropbox / OneDrive) but not downloaded locally.`,
+        `       → Right-click the file and choose "Download Now", "Make Available Offline", or "Keep on This Device".`,
+        `  2. Cloud storage app is not running or not signed in.`,
+        `       → Open your cloud storage app and make sure it is syncing.`,
+        `  3. File is on a network drive or virtual filesystem that is currently unavailable.`,
+        `       → Check that the network share or drive is mounted and accessible.`,
+        `  4. File has restricted permissions (e.g. system file, locked by another process, or chmod 000).`,
+        `       → Check file permissions or close any app that may have the file open.`,
+        `  5. The app does not have permission to access this location (macOS Full Disk Access).`,
+    ];
+    if (isMac) {
+        lines.push(`       → Go to System Settings → Privacy & Security → Full Disk Access and enable Claude.`);
+        lines.push(`       → To open that pane directly, run in terminal:`);
+        lines.push(`           open "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles"`);
+        lines.push(`         Then find "Claude" in the list and enable the toggle next to it.`);
+    }
+    else {
+        lines.push(`       → Check that the app has permission to access this file location.`);
+    }
+    return new Error(lines.join('\n'));
+}
 // Initialize allowed directories from configuration
 async function getAllowedDirs() {
     try {
@@ -307,6 +346,35 @@ export async function readFileFromDisk(filePath, options) {
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry
     const fileExtension = getFileExtension(validPath);
+    // Check if path is a directory — return listing instead of EISDIR error
+    try {
+        const stats = await fs.stat(validPath);
+        if (stats.isDirectory()) {
+            const dirListOp = async () => {
+                const entries = await listDirectory(validPath);
+                const listing = entries.join('\n');
+                return {
+                    content: `This is a directory, not a file. Use the list_directory tool instead of read_file for directories.\n\n${listing}`,
+                    mimeType: 'text/plain',
+                    metadata: { isImage: false, isDirectory: true }
+                };
+            };
+            const dirResult = await withTimeout(dirListOp(), FILE_OPERATION_TIMEOUTS.FILE_READ, 'Directory listing fallback', null);
+            if (dirResult === null) {
+                throw new Error(`Directory listing timed out for: ${filePath}`);
+            }
+            return dirResult;
+        }
+    }
+    catch (error) {
+        // If stat itself failed, fall through to the read path which will produce a proper error.
+        // But if this was a directory-listing error, re-throw — don't let it fall into the file-read path.
+        const err = error;
+        if (err.message?.includes('Directory listing') || err.message?.includes('list_directory')) {
+            throw error;
+        }
+        // stat() failed (e.g. ENOENT) — fall through to the read path below
+    }
     // Check file size before attempting to read
     try {
         const stats = await fs.stat(validPath);
@@ -357,7 +425,20 @@ export async function readFileFromDisk(filePath, options) {
         };
     };
     // Execute with timeout
-    const result = await withTimeout(readOperation(), FILE_OPERATION_TIMEOUTS.FILE_READ, `Read file operation for ${filePath}`, null);
+    let result;
+    try {
+        result = await withTimeout(readOperation(), FILE_OPERATION_TIMEOUTS.FILE_READ, `Read file operation for ${filePath}`, null);
+    }
+    catch (error) {
+        const err = error;
+        // withTimeout rejects with a plain string "__ERROR__: ... timed out after N seconds"
+        // when defaultValue is null — it has no .code property, so check for that too.
+        const isWithTimeoutString = typeof error === 'string' && error.startsWith('__ERROR__:');
+        if (isWithTimeoutString || err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'ETIMEDOUT') {
+            throw buildPermissionError(filePath, isWithTimeoutString ? 'ETIMEDOUT' : err.code);
+        }
+        throw error;
+    }
     if (result == null) {
         // Handles the impossible case where withTimeout resolves to null instead of throwing
         throw new Error('Failed to read the file');
@@ -490,9 +571,16 @@ export async function listDirectory(dirPath, depth = 2) {
             entries = await fs.readdir(currentPath, { withFileTypes: true });
         }
         catch (error) {
-            // If we can't read this directory (permission denied), show as denied
+            const err = error;
             const displayPath = relativePath || path.basename(currentPath);
-            results.push(`[DENIED] ${displayPath}`);
+            // 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') {
+                results.push(`[DENIED] ${displayPath} — not accessible (permission denied, cloud-only file, or Full Disk Access not granted)`);
+            }
+            else {
+                results.push(`[DENIED] ${displayPath}`);
+            }
             return;
         }
         // Apply filtering for nested directories (not top level)

package/dist/tools/improved-process-tools.js

@@ -27,7 +27,8 @@ async function executeNodeCode(code, timeout_ms = 30000) {
         const result = await new Promise((resolve) => {
             const proc = spawn(process.execPath, [tempFile], {
                 cwd: mcpRoot,
-                timeout: timeout_ms
+                timeout: timeout_ms,
+                windowsHide: true // Prevent visible console windows on Windows
             });
             let stdout = '';
             let stderr = '';

package/dist/tools/schemas.d.ts

@@ -3,12 +3,15 @@ export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny,
 export declare const SetConfigValueArgsSchema: z.ZodObject<{
     key: z.ZodString;
     value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodNull]>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
     value: string | number | boolean | string[] | null;
     key: string;
+    origin?: "ui" | "llm" | undefined;
 }, {
     value: string | number | boolean | string[] | null;
     key: string;
+    origin?: "ui" | "llm" | undefined;
 }>;
 export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const StartProcessArgsSchema: z.ZodObject<{

package/dist/tools/schemas.js

@@ -10,6 +10,7 @@ export const SetConfigValueArgsSchema = z.object({
         z.array(z.string()),
         z.null(),
     ]),
+    origin: z.enum(['ui', 'llm']).optional(),
 });
 // Empty schemas
 export const ListProcessesArgsSchema = z.object({});

package/dist/types.d.ts

@@ -65,7 +65,6 @@ export interface FilePreviewStructuredContent {
     fileName: string;
     filePath: string;
     fileType: PreviewFileType;
-    content: string;
     imageData?: string;
     mimeType?: string;
 }

package/dist/ui/config-editor/app.d.ts

@@ -0,0 +1,43 @@
+export interface ConfigEntry {
+    key: string;
+    label?: string;
+    description?: string;
+    value: unknown;
+    valueType: 'string' | 'number' | 'boolean' | 'array' | 'null' | string;
+    editable: boolean;
+}
+export interface ConfigEditorPayload {
+    config?: Record<string, unknown>;
+    uiHints?: {
+        availableShells?: string[];
+    };
+    entries: ConfigEntry[];
+}
+export interface ConfigEditorState {
+    payload: ConfigEditorPayload | null;
+    selectedKey: string | null;
+    draftValue: string;
+}
+export type TooltipTone = 'info' | 'error' | 'success';
+export interface TooltipMessage {
+    message: string;
+    tone: TooltipTone;
+}
+export interface ApplyConfigResult {
+    ok: boolean;
+    tooltip?: TooltipMessage;
+}
+type ToolCall = (name: string, args?: Record<string, unknown>) => Promise<unknown>;
+type TrackConfigUiEvent = (event: string, params?: Record<string, unknown>) => void;
+declare function extractPayload(result: unknown): ConfigEditorPayload | null;
+export declare function createConfigEditorController(callTool: ToolCall, trackConfigUiEvent?: TrackConfigUiEvent): {
+    state: ConfigEditorState;
+    callTool: ToolCall;
+    extractPayload: typeof extractPayload;
+    setPayload: (payload: ConfigEditorPayload | null) => void;
+    setSelection: (key: string) => void;
+    setDraftValue: (value: string) => void;
+    apply: () => Promise<ApplyConfigResult>;
+};
+export declare function bootstrapConfigEditorApp(): void;
+export {};