@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/ui/file-preview/src/markdown-workspace/linking.js

@@ -0,0 +1,210 @@
+import { slugifyMarkdownHeading } from './slugify.js';
+const WIKI_LINK_PATTERN = /\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
+const FENCE_PATTERN = /^(`{3,}|~{3,})/;
+function isWindowsAbsolutePath(value) {
+    return /^[A-Za-z]:[\\/]/.test(value);
+}
+function normalizePathSeparators(value) {
+    return value.replace(/\\/g, '/');
+}
+function normalizeFilePath(value) {
+    const normalized = normalizePathSeparators(value);
+    return normalized.replace(/\/+/g, '/');
+}
+function encodeLinkPath(pathValue) {
+    return encodeURI(normalizePathSeparators(pathValue));
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseWikiLink(rawHref) {
+    const match = rawHref.match(/^\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        path: (match[1] ?? '').trim(),
+        anchor: match[2]?.trim(),
+        alias: match[3]?.trim(),
+    };
+}
+function buildWikiDisplayText(link) {
+    if (link.alias && link.alias.length > 0) {
+        return link.alias;
+    }
+    if (link.path && link.anchor) {
+        return `${link.path}#${link.anchor}`;
+    }
+    if (link.path) {
+        return link.path;
+    }
+    return link.anchor ?? '';
+}
+function appendMarkdownExtension(pathValue) {
+    if (/\.[A-Za-z0-9_-]+$/.test(pathValue)) {
+        return pathValue;
+    }
+    return `${pathValue}.md`;
+}
+function buildWikiHref(link) {
+    if (!link.path) {
+        if (!link.anchor) {
+            return '#';
+        }
+        return `#${slugifyMarkdownHeading(link.anchor)}`;
+    }
+    const normalizedPath = appendMarkdownExtension(normalizePathSeparators(link.path));
+    const prefixedPath = normalizedPath.startsWith('./')
+        || normalizedPath.startsWith('../')
+        || normalizedPath.startsWith('/')
+        || isWindowsAbsolutePath(normalizedPath)
+        ? normalizedPath
+        : `./${normalizedPath}`;
+    const encodedPath = encodeLinkPath(prefixedPath);
+    if (!link.anchor) {
+        return encodedPath;
+    }
+    return `${encodedPath}#${slugifyMarkdownHeading(link.anchor)}`;
+}
+function replaceWikiLinksOutsideInlineCode(line) {
+    const segments = line.split(/(`[^`]*`)/g);
+    return segments.map((segment) => {
+        if (segment.startsWith('`') && segment.endsWith('`')) {
+            return segment;
+        }
+        return segment.replace(WIKI_LINK_PATTERN, (match) => {
+            const parsed = parseWikiLink(match);
+            if (!parsed) {
+                return match;
+            }
+            const displayText = buildWikiDisplayText(parsed);
+            const href = buildWikiHref(parsed);
+            return `[${displayText}](${href} "mcp-wiki:${encodeURIComponent(match)}")`;
+        });
+    }).join('');
+}
+function decodeAnchorFragment(fragment) {
+    if (!fragment || fragment.length === 0) {
+        return undefined;
+    }
+    return safeDecodeURIComponent(fragment);
+}
+function splitHref(rawHref) {
+    const hashIndex = rawHref.indexOf('#');
+    if (hashIndex === -1) {
+        return { pathPart: rawHref };
+    }
+    return {
+        pathPart: rawHref.slice(0, hashIndex),
+        anchorPart: rawHref.slice(hashIndex + 1),
+    };
+}
+function getDirectoryPath(filePath) {
+    const normalized = normalizeFilePath(filePath);
+    const lastSlashIndex = normalized.lastIndexOf('/');
+    if (lastSlashIndex < 0) {
+        return '.';
+    }
+    return lastSlashIndex === 0 ? '/' : normalized.slice(0, lastSlashIndex);
+}
+function toDirectoryFileUrl(directoryPath) {
+    const normalized = normalizeFilePath(directoryPath);
+    const withTrailingSlash = normalized.endsWith('/') ? normalized : `${normalized}/`;
+    if (isWindowsAbsolutePath(withTrailingSlash)) {
+        return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+    }
+    if (withTrailingSlash.startsWith('/')) {
+        return new URL(`file://${encodeLinkPath(withTrailingSlash)}`);
+    }
+    return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+}
+function fromFileUrl(url) {
+    const decodedPath = safeDecodeURIComponent(url.pathname);
+    if (/^\/[A-Za-z]:\//.test(decodedPath)) {
+        return decodedPath.slice(1);
+    }
+    return decodedPath;
+}
+function isExternalHref(rawHref) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(rawHref) && !isWindowsAbsolutePath(rawHref);
+}
+function resolveFileTargetPath(currentPath, rawPath) {
+    const normalizedRawPath = normalizePathSeparators(safeDecodeURIComponent(rawPath));
+    if (normalizedRawPath.startsWith('/') || isWindowsAbsolutePath(normalizedRawPath)) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const baseDirectory = getDirectoryPath(currentPath);
+    if (baseDirectory === '.' && !normalizeFilePath(currentPath).includes('/')) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const resolvedUrl = new URL(encodeURI(normalizedRawPath), toDirectoryFileUrl(baseDirectory));
+    return normalizeFilePath(fromFileUrl(resolvedUrl));
+}
+export function rewriteWikiLinks(source) {
+    const lines = source.split('\n');
+    let activeFence = null;
+    return lines.map((line) => {
+        const trimmedStart = line.trimStart();
+        const fenceMatch = trimmedStart.match(FENCE_PATTERN);
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            if (!activeFence) {
+                activeFence = marker;
+            }
+            else if (marker[0] === activeFence[0] && marker.length >= activeFence.length) {
+                activeFence = null;
+            }
+            return line;
+        }
+        if (activeFence) {
+            return line;
+        }
+        return replaceWikiLinksOutsideInlineCode(line);
+    }).join('\n');
+}
+export function resolveMarkdownLink(currentPath, rawHref) {
+    const wikiLink = parseWikiLink(rawHref);
+    if (wikiLink) {
+        const href = buildWikiHref(wikiLink);
+        if (href.startsWith('#')) {
+            return {
+                kind: 'anchor',
+                href: rawHref,
+                anchor: decodeAnchorFragment(href.slice(1)),
+            };
+        }
+        const [pathPart, anchorPart] = href.split('#');
+        return {
+            kind: 'file',
+            href: rawHref,
+            targetPath: resolveFileTargetPath(currentPath, pathPart),
+            ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+        };
+    }
+    if (isExternalHref(rawHref)) {
+        return {
+            kind: 'external',
+            href: rawHref,
+            url: rawHref,
+        };
+    }
+    if (rawHref.startsWith('#')) {
+        return {
+            kind: 'anchor',
+            href: rawHref,
+            anchor: decodeAnchorFragment(rawHref.slice(1)),
+        };
+    }
+    const { pathPart, anchorPart } = splitHref(rawHref);
+    return {
+        kind: 'file',
+        href: rawHref,
+        targetPath: resolveFileTargetPath(currentPath, pathPart),
+        ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+    };
+}

package/dist/ui/file-preview/src/markdown-workspace/outline.d.ts

@@ -0,0 +1,7 @@
+export interface MarkdownOutlineItem {
+    id: string;
+    text: string;
+    level: number;
+    line: number;
+}
+export declare function extractMarkdownOutline(source: string): MarkdownOutlineItem[];

package/dist/ui/file-preview/src/markdown-workspace/outline.js

@@ -0,0 +1,40 @@
+// markdown-it is intentionally typed locally here to avoid maintaining ambient module declarations.
+// @ts-expect-error markdown-it does not provide local TypeScript typings in this setup.
+import MarkdownIt from 'markdown-it';
+import { rewriteWikiLinks } from './linking.js';
+import { createSlugTracker } from './slugify.js';
+import { extractInlineText } from './utils.js';
+const MarkdownItCtor = MarkdownIt;
+const outlineParser = new MarkdownItCtor({
+    html: false,
+    linkify: true,
+    typographer: false,
+});
+export function extractMarkdownOutline(source) {
+    const tokens = outlineParser.parse(rewriteWikiLinks(source), {});
+    const nextSlug = createSlugTracker();
+    const outline = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token.type !== 'heading_open' || typeof token.tag !== 'string') {
+            continue;
+        }
+        const level = Number.parseInt(token.tag.replace(/^h/i, ''), 10);
+        if (!Number.isFinite(level)) {
+            continue;
+        }
+        const inlineToken = tokens[index + 1];
+        const text = extractInlineText(inlineToken).trim();
+        if (!text) {
+            continue;
+        }
+        const lineMap = Array.isArray(token.map) ? token.map : undefined;
+        outline.push({
+            id: nextSlug(text),
+            text,
+            level,
+            line: Array.isArray(lineMap) && typeof lineMap[0] === 'number' ? lineMap[0] + 1 : outline.length + 1,
+        });
+    }
+    return outline;
+}

package/dist/ui/file-preview/src/markdown-workspace/preview.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownOutlineItem } from './outline.js';
+export declare function getRenderedMarkdownCopyText(content: string): string;
+export declare function renderMarkdownWorkspacePreview(options: {
+    content: string;
+    outline: MarkdownOutlineItem[];
+    activeHeadingId?: string | null;
+    showToc?: boolean;
+}): string;

package/dist/ui/file-preview/src/markdown-workspace/preview.js

@@ -0,0 +1,33 @@
+import { renderMarkdown } from '../components/markdown-renderer.js';
+import { renderMarkdownToc } from './toc.js';
+export function getRenderedMarkdownCopyText(content) {
+    const html = renderMarkdown(content);
+    const normalizedHtml = html
+        .replace(/<\s*br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n\n')
+        .replace(/<\/h[1-6]>/gi, '\n\n')
+        .replace(/<\/li>/gi, '\n')
+        .replace(/<li>/gi, '- ')
+        .replace(/<[^>]+>/g, '');
+    return normalizedHtml
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function renderMarkdownWorkspacePreview(options) {
+    const tocHtml = options.showToc ? renderMarkdownToc(options.outline, options.activeHeadingId) : '';
+    const hasToc = tocHtml.length > 0;
+    return `
+      <div class="markdown-workspace markdown-workspace--preview${hasToc ? ' markdown-workspace--with-toc' : ''}">
+        ${tocHtml}
+        <section class="markdown-workspace-main">
+          <article class="markdown markdown-doc">${renderMarkdown(options.content)}</article>
+        </section>
+      </div>
+    `;
+}

package/dist/ui/file-preview/src/markdown-workspace/slugify.d.ts

@@ -0,0 +1,3 @@
+export type MarkdownSlugTracker = (text: string) => string;
+export declare function slugifyMarkdownHeading(text: string): string;
+export declare function createSlugTracker(): MarkdownSlugTracker;

package/dist/ui/file-preview/src/markdown-workspace/slugify.js

@@ -0,0 +1,31 @@
+function sanitizeSlugPart(text) {
+    const normalized = text
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized.length > 0 ? normalized : 'section';
+}
+export function slugifyMarkdownHeading(text) {
+    return sanitizeSlugPart(text);
+}
+export function createSlugTracker() {
+    const counts = new Map();
+    const usedSlugs = new Set();
+    return (text) => {
+        const baseSlug = slugifyMarkdownHeading(text);
+        let nextCount = counts.get(baseSlug) ?? 1;
+        let nextSlug = nextCount === 1 ? baseSlug : `${baseSlug}-${nextCount}`;
+        while (usedSlugs.has(nextSlug)) {
+            nextCount += 1;
+            nextSlug = `${baseSlug}-${nextCount}`;
+        }
+        counts.set(baseSlug, nextCount + 1);
+        usedSlugs.add(nextSlug);
+        return nextSlug;
+    };
+}

package/dist/ui/file-preview/src/markdown-workspace/toc.d.ts

@@ -0,0 +1,11 @@
+import type { MarkdownOutlineItem } from './outline.js';
+export interface MarkdownTocHandle {
+    dispose: () => void;
+}
+export declare function renderMarkdownToc(outline: MarkdownOutlineItem[], activeHeadingId?: string | null): string;
+export declare function attachMarkdownToc(options: {
+    shell: HTMLElement;
+    outline: MarkdownOutlineItem[];
+    scrollContainer: HTMLElement;
+    onSelect: (headingId: string) => void;
+}): MarkdownTocHandle | null;

package/dist/ui/file-preview/src/markdown-workspace/toc.js

@@ -0,0 +1,75 @@
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function setActiveItem(nav, activeId) {
+    const buttons = Array.from(nav.querySelectorAll('[data-toc-id]'));
+    buttons.forEach((button) => {
+        const isActive = button.dataset.tocId === activeId;
+        button.classList.toggle('is-active', isActive);
+        button.setAttribute('aria-current', isActive ? 'location' : 'false');
+    });
+}
+export function renderMarkdownToc(outline, activeHeadingId) {
+    if (outline.length === 0) {
+        return '';
+    }
+    const items = outline.map((item) => {
+        const activeClass = item.id === activeHeadingId ? ' is-active' : '';
+        return `<button class="markdown-toc-link${activeClass}" type="button" data-toc-id="${escapeHtml(item.id)}" data-level="${item.level}" aria-current="${item.id === activeHeadingId ? 'location' : 'false'}">${escapeHtml(item.text)}</button>`;
+    }).join('');
+    return `
+      <aside class="markdown-toc-shell" aria-label="Table of contents">
+        <div class="markdown-toc-title">Contents</div>
+        <nav class="markdown-toc-nav">${items}</nav>
+      </aside>
+    `;
+}
+export function attachMarkdownToc(options) {
+    const nav = options.shell.querySelector('.markdown-toc-nav');
+    if (!nav) {
+        return null;
+    }
+    const handleClick = (event) => {
+        const target = event.target;
+        const button = target?.closest('[data-toc-id]');
+        const headingId = button?.dataset.tocId;
+        if (!headingId) {
+            return;
+        }
+        options.onSelect(headingId);
+        setActiveItem(nav, headingId);
+    };
+    const updateActiveHeading = () => {
+        const headings = options.outline
+            .map((item) => {
+            const element = document.getElementById(item.id);
+            return element ? { item, element } : null;
+        })
+            .filter((entry) => entry !== null);
+        if (headings.length === 0) {
+            return;
+        }
+        const scrollTop = options.scrollContainer.scrollTop;
+        const nextActive = headings.reduce((activeId, current) => {
+            if (current.element.offsetTop - scrollTop <= 96) {
+                return current.item.id;
+            }
+            return activeId;
+        }, headings[0].item.id);
+        setActiveItem(nav, nextActive);
+    };
+    nav.addEventListener('click', handleClick);
+    options.scrollContainer.addEventListener('scroll', updateActiveHeading, { passive: true });
+    updateActiveHeading();
+    return {
+        dispose: () => {
+            nav.removeEventListener('click', handleClick);
+            options.scrollContainer.removeEventListener('scroll', updateActiveHeading);
+        },
+    };
+}

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

@@ -0,0 +1 @@
+export declare function extractInlineText(token: Record<string, unknown> | undefined): string;

package/dist/ui/file-preview/src/markdown-workspace/utils.js

@@ -0,0 +1,15 @@
+export function extractInlineText(token) {
+    if (!token) {
+        return '';
+    }
+    const children = Array.isArray(token.children) ? token.children : [];
+    if (children.length === 0) {
+        return typeof token.content === 'string' ? token.content : '';
+    }
+    return children.map((child) => {
+        if (typeof child.content === 'string') {
+            return child.content;
+        }
+        return '';
+    }).join('');
+}

package/dist/ui/file-preview/src/markdown-workspace/workspace-controller.d.ts

@@ -0,0 +1,25 @@
+export interface ReadRange {
+    fromLine: number;
+    toLine: number;
+    totalLines: number;
+    isPartial: boolean;
+}
+export declare function stripReadStatusLine(content: string): string;
+export declare function parseReadRange(content: string): ReadRange | undefined;
+export declare function getMarkdownEditAvailability(options: {
+    content: string;
+}): {
+    canEdit: true;
+} | {
+    canEdit: false;
+    reason: string;
+};
+export declare function getMarkdownFullscreenAvailability(options: {
+    availableDisplayModes?: string[];
+}): {
+    canFullscreen: true;
+} | {
+    canFullscreen: false;
+    reason: string;
+};
+export declare function shouldAutoLoadMarkdownOnEnterFullscreen(content: string): boolean;

package/dist/ui/file-preview/src/markdown-workspace/workspace-controller.js

@@ -0,0 +1,40 @@
+export function stripReadStatusLine(content) {
+    return content.replace(/^\[Reading [^\]]+\]\r?\n(?:\r?\n)?/, '');
+}
+export function parseReadRange(content) {
+    const match = content.match(/^\[Reading (\d+) lines from (?:line )?(\d+|start) \(total: (\d+) lines/);
+    if (!match) {
+        return undefined;
+    }
+    const count = Number.parseInt(match[1], 10);
+    const fromLine = match[2] === 'start' ? 1 : Number.parseInt(match[2], 10);
+    const totalLines = Number.parseInt(match[3], 10);
+    return {
+        fromLine,
+        toLine: fromLine + count - 1,
+        totalLines,
+        isPartial: count < totalLines,
+    };
+}
+export function getMarkdownEditAvailability(options) {
+    const readRange = parseReadRange(options.content);
+    if (readRange?.isPartial) {
+        return {
+            canEdit: false,
+            reason: 'Load the full document before editing.',
+        };
+    }
+    return { canEdit: true };
+}
+export function getMarkdownFullscreenAvailability(options) {
+    if (!options.availableDisplayModes?.includes('fullscreen')) {
+        return {
+            canFullscreen: false,
+            reason: 'Fullscreen editing is unavailable in this host.',
+        };
+    }
+    return { canFullscreen: true };
+}
+export function shouldAutoLoadMarkdownOnEnterFullscreen(content) {
+    return parseReadRange(content)?.isPartial === true;
+}

package/dist/ui/file-preview/src/model.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentOutlineItem } from './document-outline.js';
+import type { FilePreviewStructuredContent } from '../../../types.js';
+import type { MarkdownEditorView } from './markdown/editor.js';
+export type RenderPayload = FilePreviewStructuredContent & {
+    content: string;
+};
+export interface MarkdownWorkspaceState {
+    filePath: string;
+    sourceContent: string;
+    fullDocumentContent: string;
+    draftContent: string;
+    outline: DocumentOutlineItem[];
+    mode: 'edit';
+    dirty: boolean;
+    activeHeadingId: string | null;
+    pendingAnchor: string | null;
+    notice: string | null;
+    error: string | null;
+    saving: boolean;
+    loadingDocument: boolean;
+    editorView: MarkdownEditorView;
+    editorScrollTop: number;
+    saveIndicator: 'idle' | 'saving' | 'saved';
+    fileDeleted: boolean;
+}
+export interface RenderBodyResult {
+    html: string;
+    notice?: string;
+}
+export interface FileTypeCapabilities {
+    supportsPreview: boolean;
+    canCopy: boolean;
+    canOpenInFolder: boolean;
+}

package/dist/ui/file-preview/src/panel-actions.d.ts

@@ -0,0 +1,17 @@
+import type { RenderPayload } from './model.js';
+import type { MarkdownController } from './markdown/controller.js';
+import type { HtmlPreviewMode } from './types.js';
+export declare function attachPanelActions(options: {
+    container: HTMLElement;
+    payload: RenderPayload;
+    htmlMode: HtmlPreviewMode;
+    getIsExpanded: () => boolean;
+    callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
+    trackUiEvent?: (event: string, params?: Record<string, unknown>) => void;
+    getFileExtensionForAnalytics: (filePath: string) => string;
+    buildOpenInFolderCommand: (filePath: string) => string | undefined;
+    buildOpenInEditorCommand: (filePath: string) => string | undefined;
+    render: (payload?: RenderPayload, htmlMode?: HtmlPreviewMode, expandedState?: boolean) => void;
+    updateSaveStatus: (label: string, statusClass: string) => void;
+    markdownController: MarkdownController;
+}): void;