@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/ui/file-preview/src/panel-actions.js

@@ -0,0 +1,182 @@
+import { parseReadRange, stripReadStatusLine } from './document-workspace.js';
+import { extractToolText } from './payload-utils.js';
+export function attachPanelActions(options) {
+    const queryById = (id) => (options.container.querySelector(`#${id}`));
+    const fallbackCopy = (text) => {
+        const textArea = document.createElement('textarea');
+        textArea.value = text;
+        textArea.setAttribute('readonly', '');
+        textArea.style.position = 'fixed';
+        textArea.style.top = '-9999px';
+        document.body.appendChild(textArea);
+        textArea.select();
+        const success = document.execCommand('copy');
+        document.body.removeChild(textArea);
+        return success;
+    };
+    const setButtonState = (button, label, fallbackLabel, revertMs) => {
+        button.setAttribute('title', label);
+        button.setAttribute('aria-label', label);
+        button.textContent = label;
+        if (revertMs) {
+            setTimeout(() => {
+                button.textContent = fallbackLabel;
+                button.setAttribute('title', fallbackLabel);
+                button.setAttribute('aria-label', fallbackLabel);
+            }, revertMs);
+        }
+    };
+    const setIconButtonState = (button, label, fallbackLabel, revertMs) => {
+        button.setAttribute('title', label);
+        button.setAttribute('aria-label', label);
+        button.dataset.status = label;
+        if (revertMs) {
+            setTimeout(() => {
+                button.setAttribute('title', fallbackLabel);
+                button.setAttribute('aria-label', fallbackLabel);
+                delete button.dataset.status;
+            }, revertMs);
+        }
+    };
+    const copyTextData = async (text) => {
+        try {
+            if (navigator.clipboard?.writeText) {
+                await navigator.clipboard.writeText(text);
+                return true;
+            }
+            return fallbackCopy(text);
+        }
+        catch {
+            return fallbackCopy(text);
+        }
+    };
+    const fileExtension = options.getFileExtensionForAnalytics(options.payload.filePath);
+    const copyButton = queryById('copy-source');
+    copyButton?.addEventListener('click', async () => {
+        options.trackUiEvent?.('copy_clicked', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        const copied = await copyTextData(stripReadStatusLine(options.payload.content));
+        setButtonState(copyButton, copied ? 'Copied!' : 'Copy failed', 'Copy', 1500);
+    });
+    const activeCopyButton = queryById('copy-active-markdown');
+    activeCopyButton?.addEventListener('click', async () => {
+        const textToCopy = options.markdownController.getCopyText(options.payload);
+        if (!textToCopy) {
+            return;
+        }
+        const copied = await copyTextData(textToCopy);
+        if (copied) {
+            options.updateSaveStatus('Copied', 'saved');
+            window.setTimeout(() => options.updateSaveStatus('', ''), 1500);
+        }
+        setIconButtonState(activeCopyButton, copied ? 'Copied!' : 'Copy failed', 'Copy', 1500);
+    });
+    const toggleButton = queryById('toggle-html-mode');
+    toggleButton?.addEventListener('click', () => {
+        const nextMode = options.htmlMode === 'rendered' ? 'source' : 'rendered';
+        options.trackUiEvent?.('html_view_toggled', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        options.render(options.payload, nextMode, options.getIsExpanded());
+    });
+    const openFolderButton = queryById('open-in-folder');
+    if (openFolderButton) {
+        const command = options.buildOpenInFolderCommand(options.payload.filePath);
+        if (!command) {
+            openFolderButton.disabled = true;
+        }
+        else {
+            openFolderButton.addEventListener('click', async () => {
+                options.trackUiEvent?.('open_in_folder', {
+                    file_type: options.payload.fileType,
+                    file_extension: fileExtension,
+                });
+                try {
+                    await options.callTool?.('start_process', { command, timeout_ms: 12000 });
+                }
+                catch {
+                    // Keep UI stable if opening folder fails.
+                }
+            });
+        }
+    }
+    const openEditorButton = queryById('open-in-editor');
+    if (openEditorButton) {
+        const command = options.buildOpenInEditorCommand(options.payload.filePath);
+        if (!command) {
+            openEditorButton.disabled = true;
+        }
+        else {
+            openEditorButton.addEventListener('click', async () => {
+                options.trackUiEvent?.('open_in_editor', {
+                    file_type: options.payload.fileType,
+                    file_extension: fileExtension,
+                });
+                try {
+                    await options.callTool?.('start_process', { command, timeout_ms: 12000 });
+                }
+                catch {
+                    // Keep UI stable if opening editor fails.
+                }
+            });
+        }
+    }
+    const beforeBtn = queryById('load-before');
+    const afterBtn = queryById('load-after');
+    if (!beforeBtn && !afterBtn) {
+        return;
+    }
+    const range = parseReadRange(options.payload.content);
+    if (!range?.isPartial) {
+        return;
+    }
+    const currentContent = stripReadStatusLine(options.payload.content);
+    const loadLines = async (button, direction) => {
+        const originalText = button.textContent;
+        button.textContent = 'Loading…';
+        button.disabled = true;
+        options.trackUiEvent?.(direction === 'before' ? 'load_lines_before' : 'load_lines_after', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        try {
+            const readArgs = direction === 'before'
+                ? { path: options.payload.filePath, offset: 0, length: range.fromLine - 1 }
+                : { path: options.payload.filePath, offset: range.toLine };
+            const result = await options.callTool?.('read_file', readArgs);
+            const newText = extractToolText(result);
+            if (newText && typeof newText === 'string') {
+                const cleanNew = stripReadStatusLine(newText);
+                const merged = direction === 'before'
+                    ? `${cleanNew}${cleanNew.endsWith('\n') ? '' : '\n'}${currentContent}`
+                    : `${currentContent}${currentContent.endsWith('\n') ? '' : '\n'}${cleanNew}`;
+                const newFrom = direction === 'before' ? 1 : range.fromLine;
+                const newTo = direction === 'after' ? range.totalLines : range.toLine;
+                const lineCount = newTo - newFrom + 1;
+                const remaining = range.totalLines - newTo;
+                const isStillPartial = newFrom > 1 || newTo < range.totalLines;
+                const statusLine = isStillPartial
+                    ? `[Reading ${lineCount} lines from ${newFrom === 1 ? 'start' : `line ${newFrom}`} (total: ${range.totalLines} lines, ${remaining} remaining)]\n`
+                    : '';
+                options.render({
+                    ...options.payload,
+                    content: statusLine + merged,
+                }, options.htmlMode, options.getIsExpanded());
+                return;
+            }
+        }
+        catch {
+            // Fall through to button reset.
+        }
+        button.textContent = 'Failed to load';
+        setTimeout(() => {
+            button.textContent = originalText;
+            button.disabled = false;
+        }, 2000);
+    };
+    beforeBtn?.addEventListener('click', () => void loadLines(beforeBtn, 'before'));
+    afterBtn?.addEventListener('click', () => void loadLines(afterBtn, 'after'));
+}

package/dist/ui/file-preview/src/path-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function isWindowsAbsolutePath(value: string): boolean;
+export declare function normalizePathSeparators(value: string): string;
+export declare function normalizeFilePath(value: string): string;
+export declare function getParentDirectory(filePath: string): string;
+export declare function getAncestorDirectories(filePath: string): string[];
+export declare function toPosixRelativePath(fromDirectory: string, targetPath: string): string;

package/dist/ui/file-preview/src/path-utils.js

@@ -0,0 +1,64 @@
+export function isWindowsAbsolutePath(value) {
+    return /^[A-Za-z]:[\\/]/.test(value);
+}
+export function normalizePathSeparators(value) {
+    return value.replace(/\\/g, '/');
+}
+export function normalizeFilePath(value) {
+    const normalized = normalizePathSeparators(value);
+    return normalized.replace(/\/+/g, '/');
+}
+function getPathRoot(value) {
+    const normalized = normalizeFilePath(value);
+    if (isWindowsAbsolutePath(normalized)) {
+        return normalized.slice(0, 3);
+    }
+    return normalized.startsWith('/') ? '/' : '';
+}
+function getPathSegments(value) {
+    const normalized = normalizeFilePath(value);
+    const root = getPathRoot(normalized);
+    return normalized.slice(root.length).split('/').filter(Boolean);
+}
+export function getParentDirectory(filePath) {
+    const root = getPathRoot(filePath);
+    const segments = getPathSegments(filePath);
+    if (segments.length <= 1) {
+        return root || '.';
+    }
+    return `${root}${segments.slice(0, -1).join('/')}`;
+}
+export function getAncestorDirectories(filePath) {
+    const root = getPathRoot(filePath);
+    const segments = getPathSegments(filePath);
+    const ancestors = [];
+    for (let index = segments.length - 1; index >= 1; index -= 1) {
+        const ancestor = `${root}${segments.slice(0, index).join('/')}`;
+        ancestors.push(ancestor || '.');
+    }
+    if (root && ancestors[ancestors.length - 1] !== root) {
+        ancestors.push(root);
+    }
+    return ancestors;
+}
+export function toPosixRelativePath(fromDirectory, targetPath) {
+    const normalizedFrom = normalizeFilePath(fromDirectory);
+    const normalizedTarget = normalizeFilePath(targetPath);
+    const fromRoot = getPathRoot(normalizedFrom);
+    const targetRoot = getPathRoot(normalizedTarget);
+    if (fromRoot !== targetRoot) {
+        return normalizedTarget;
+    }
+    const fromParts = getPathSegments(normalizedFrom);
+    const targetParts = getPathSegments(normalizedTarget);
+    let shared = 0;
+    while (shared < fromParts.length
+        && shared < targetParts.length
+        && fromParts[shared] === targetParts[shared]) {
+        shared += 1;
+    }
+    const up = new Array(Math.max(fromParts.length - shared, 0)).fill('..');
+    const down = targetParts.slice(shared);
+    const joined = [...up, ...down].join('/');
+    return joined.length > 0 ? joined : '.';
+}

package/dist/ui/file-preview/src/payload-utils.d.ts

@@ -0,0 +1,11 @@
+import type { FilePreviewStructuredContent } from '../../../types.js';
+import type { RenderPayload } from './model.js';
+export declare function getFileExtensionForAnalytics(filePath: string): string;
+export declare function isPreviewStructuredContent(value: unknown): value is FilePreviewStructuredContent;
+export declare function buildRenderPayload(meta: FilePreviewStructuredContent, text: string): RenderPayload;
+export declare function extractToolText(value: unknown): string | undefined;
+export declare function extractRenderPayload(value: unknown): RenderPayload | undefined;
+export declare function assertSuccessfulEditBlockResult(result: unknown): void;
+export declare function isLikelyUrl(filePath: string): boolean;
+export declare function buildBreadcrumb(filePath: string): string;
+export declare function countContentLines(content: string): number;

package/dist/ui/file-preview/src/payload-utils.js

@@ -0,0 +1,94 @@
+import { escapeHtml } from './components/highlighting.js';
+import { stripReadStatusLine } from './document-workspace.js';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function getFileExtensionForAnalytics(filePath) {
+    const normalizedPath = filePath.trim().replace(/\\/g, '/');
+    const fileName = normalizedPath.split('/').pop() ?? normalizedPath;
+    const dotIndex = fileName.lastIndexOf('.');
+    if (dotIndex <= 0 || dotIndex === fileName.length - 1) {
+        return 'none';
+    }
+    return fileName.slice(dotIndex + 1).toLowerCase();
+}
+export function isPreviewStructuredContent(value) {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    return (typeof value.fileName === 'string' &&
+        typeof value.filePath === 'string' &&
+        typeof value.fileType === 'string');
+}
+export function buildRenderPayload(meta, text) {
+    return { ...meta, content: text };
+}
+export function extractToolText(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const content = value.content;
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    for (const item of content) {
+        if (!isObjectRecord(item)) {
+            continue;
+        }
+        if (item.type === 'text' && typeof item.text === 'string' && item.text.trim().length > 0) {
+            return item.text;
+        }
+    }
+    return undefined;
+}
+export function extractRenderPayload(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const meta = isPreviewStructuredContent(value.structuredContent)
+        ? value.structuredContent
+        : isPreviewStructuredContent(value)
+            ? value
+            : null;
+    if (!meta)
+        return undefined;
+    const text = extractToolText(value) ?? extractToolText(value.structuredContent) ?? '';
+    return buildRenderPayload(meta, text);
+}
+export function assertSuccessfulEditBlockResult(result) {
+    if (!isObjectRecord(result)) {
+        throw new Error('edit_block did not return a valid result.');
+    }
+    if (result.isError === true) {
+        const message = extractToolText(result) ?? '';
+        throw new Error(message || 'edit_block failed.');
+    }
+    // edit_block uses soft-failure returns (no isError flag) for cases the LLM
+    // is meant to recover from — "Search content not found", "Expected N
+    // occurrences but found M", fuzzy-match-too-close-to-ignore, etc. These
+    // look like success to a naive client. A real success always carries
+    // structuredContent (see src/tools/edit.ts — the write path attaches
+    // fileName/filePath/fileType); absence means the edit did not land.
+    // Throwing here routes soft failures through saveDocument's catch, which
+    // reloads disk, preserves the user's draft, and surfaces the server's
+    // message to the user.
+    if (!isObjectRecord(result.structuredContent)) {
+        const message = extractToolText(result) ?? '';
+        throw new Error(message || 'edit_block did not confirm success.');
+    }
+}
+export function isLikelyUrl(filePath) {
+    return /^https?:\/\//i.test(filePath);
+}
+export function buildBreadcrumb(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    return parts.map((part) => escapeHtml(part)).join(' <span class="breadcrumb-sep">›</span> ');
+}
+export function countContentLines(content) {
+    const cleaned = stripReadStatusLine(content);
+    if (cleaned === '')
+        return 0;
+    const lines = cleaned.split('\n');
+    return lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
+}