@wonderwhy-er/desktop-commander 0.2.34 → 0.2.36

package/dist/tools/docx/utils.js

@@ -0,0 +1,299 @@
+/**
+ * DOCX Utility Functions
+ * Helper functions for DOCX operations, validation, and data transformation
+ */
+import fs from 'fs/promises';
+import path from 'path';
+// Import types from docx for image handling
+// @ts-ignore - docx library has incomplete type definitions but exports exist at runtime
+import * as docx from 'docx';
+const { ImageRun, } = docx;
+import { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
+/**
+ * Check if a string is a valid data URL
+ */
+export function isDataUrl(src) {
+    return src.startsWith('data:') && src.includes('base64,');
+}
+/**
+ * Check if a source is a URL (http/https)
+ */
+export function isUrl(src) {
+    return src.startsWith('http://') || src.startsWith('https://');
+}
+/**
+ * Parse data URL into buffer
+ * @returns Buffer if successful, null if invalid
+ */
+export function parseDataUrl(dataUrl) {
+    try {
+        const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+        if (!match)
+            return null;
+        return Buffer.from(match[2], 'base64');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve image path relative to base directory
+ */
+export function resolveImagePath(imagePath, baseDir) {
+    if (path.isAbsolute(imagePath) || isUrl(imagePath) || isDataUrl(imagePath)) {
+        return imagePath;
+    }
+    if (!baseDir) {
+        return path.resolve(imagePath);
+    }
+    return path.join(baseDir, imagePath);
+}
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate image file
+ */
+export async function validateImageFile(imagePath) {
+    if (isDataUrl(imagePath)) {
+        const buffer = parseDataUrl(imagePath);
+        if (!buffer) {
+            return { valid: false, error: 'Invalid data URL format' };
+        }
+        return { valid: true };
+    }
+    if (isUrl(imagePath)) {
+        // For URLs, we'll validate during fetch
+        return { valid: true };
+    }
+    const exists = await fileExists(imagePath);
+    if (!exists) {
+        return { valid: false, error: `Image file not found: ${imagePath}` };
+    }
+    // Check file extension
+    const ext = path.extname(imagePath).toLowerCase();
+    const validExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg'];
+    if (!validExtensions.includes(ext)) {
+        return { valid: false, error: `Unsupported image format: ${ext}` };
+    }
+    return { valid: true };
+}
+/**
+ * Escape special regex characters for literal string matching
+ */
+export function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Validate markdown table format
+ */
+export function isValidMarkdownTable(markdown) {
+    const lines = markdown.trim().split('\n');
+    if (lines.length < 2)
+        return false;
+    // Check header row
+    const headerLine = lines[0].trim();
+    if (!headerLine.startsWith('|') || !headerLine.endsWith('|'))
+        return false;
+    // Check separator row
+    const separatorLine = lines[1].trim();
+    if (!separatorLine.startsWith('|') || !separatorLine.endsWith('|'))
+        return false;
+    // Verify separator contains dashes
+    const separatorPattern = /^(\|\s*:?-{2,}\s*:?\s*)+\|$/;
+    if (!separatorPattern.test(separatorLine))
+        return false;
+    return true;
+}
+/**
+ * Build a markdown table from a 2D array of rows
+ */
+export function buildMarkdownTableFromRows(rows) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const header = rows[0];
+    const dataRows = rows.slice(1);
+    const headerLine = `| ${header.join(' | ')} |`;
+    const separatorLine = `| ${header.map(() => '---').join(' | ')} |`;
+    const dataLines = dataRows.map((r) => `| ${r.join(' | ')} |`);
+    return [headerLine, separatorLine, ...dataLines].join('\n');
+}
+/**
+ * Parse markdown table into 2D array
+ */
+export function parseMarkdownTable(markdown) {
+    if (!isValidMarkdownTable(markdown)) {
+        return null;
+    }
+    const lines = markdown.trim().split('\n');
+    const rows = [];
+    for (let i = 0; i < lines.length; i++) {
+        // Skip separator line
+        if (i === 1)
+            continue;
+        const line = lines[i].trim();
+        const cells = line
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map(cell => cell.trim());
+        rows.push(cells);
+    }
+    return rows;
+}
+/**
+ * Get MIME type from file extension or data URL
+ */
+export function getMimeType(source) {
+    if (isDataUrl(source)) {
+        const match = source.match(/^data:([^;]+);/);
+        return match ? match[1] : null;
+    }
+    const ext = path.extname(source).toLowerCase();
+    const mimeTypes = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.bmp': 'image/bmp',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+    };
+    return mimeTypes[ext] || null;
+}
+/**
+ * Format file size in human-readable format
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+/**
+ * Normalize line endings to \n
+ */
+export function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+/**
+ * Split markdown into lines, preserving empty lines
+ */
+export function splitMarkdownLines(markdown) {
+    return normalizeLineEndings(markdown).split('\n');
+}
+/**
+ * Validate DOCX file path
+ */
+export function isDocxPath(filePath) {
+    return filePath.toLowerCase().endsWith('.docx');
+}
+/**
+ * Extract file name without extension
+ */
+export function getFileNameWithoutExtension(filePath) {
+    const basename = path.basename(filePath);
+    return basename.replace(/\.docx$/i, '');
+}
+// Re-export error handling from errors module
+export { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
+/**
+ * Load and prepare an image for DOCX embedding
+ * Handles both local files and data URLs
+ *
+ * @param imagePath - Path to image file or data URL
+ * @param altText - Alternative text for the image
+ * @param baseDir - Base directory for resolving relative paths
+ * @returns Prepared image data ready for embedding
+ */
+export async function prepareImageForDocx(imagePath, altText = '', baseDir) {
+    return withErrorContext(async () => {
+        let buffer;
+        let mimeType = 'image/png'; // Default
+        // Handle data URL
+        if (isDataUrl(imagePath)) {
+            const parsed = parseDataUrl(imagePath);
+            if (!parsed) {
+                throw new DocxError('Invalid data URL format', DocxErrorCode.INVALID_IMAGE_DATA_URL, { imagePath: imagePath.substring(0, 50) });
+            }
+            buffer = parsed;
+            // Extract MIME type from data URL
+            const mimeMatch = imagePath.match(/^data:([^;]+);/);
+            if (mimeMatch) {
+                mimeType = mimeMatch[1];
+            }
+        }
+        else {
+            // Handle file path
+            const resolved = resolveImagePath(imagePath, baseDir);
+            // Validate image file
+            const validation = await validateImageFile(resolved);
+            if (!validation.valid) {
+                throw new DocxError(validation.error || 'Invalid image file', DocxErrorCode.INVALID_IMAGE_FILE, { imagePath: resolved });
+            }
+            // Read image file
+            try {
+                buffer = await fs.readFile(resolved);
+            }
+            catch (error) {
+                throw new DocxError(`Failed to read image file: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_READ_FAILED, { imagePath: resolved });
+            }
+            // Determine MIME type from file extension
+            const ext = path.extname(resolved).toLowerCase();
+            const mimeTypes = {
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.bmp': 'image/bmp',
+                '.webp': 'image/webp',
+            };
+            mimeType = mimeTypes[ext] || 'image/png';
+        }
+        return {
+            buffer,
+            altText: altText || path.basename(imagePath),
+            mimeType,
+            // Default dimensions - can be customized
+            width: 600,
+            height: 400,
+        };
+    }, DocxErrorCode.IMAGE_PREPARATION_FAILED, { imagePath });
+}
+/**
+ * Create an ImageRun instance for embedding in DOCX paragraphs
+ * This is a lower-level utility for direct image insertion
+ *
+ * @param imageData - Prepared image data
+ * @returns ImageRun instance ready to be added to a paragraph
+ */
+export function createImageRun(imageData) {
+    try {
+        return new ImageRun({
+            data: imageData.buffer,
+            transformation: {
+                width: imageData.width || 600,
+                height: imageData.height || 400,
+            },
+            altText: {
+                title: imageData.altText,
+                description: imageData.altText,
+            },
+        });
+    }
+    catch (error) {
+        throw new DocxError(`Failed to create image run: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_RUN_CREATION_FAILED);
+    }
+}

package/dist/tools/docx/validate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Invariant validation for DOCX write operations.
+ *
+ * Single Responsibility: capture a structural snapshot of w:body and
+ * compare before / after snapshots to guarantee no accidental breakage.
+ */
+import type { BodySnapshot } from './types.js';
+export interface ValidationOptions {
+    /**
+     * Expected change in w:body direct child count.
+     * Positive = inserts, negative = deletes.
+     * Default 0 (no structural changes expected).
+     */
+    expectedChildDelta?: number;
+    /**
+     * Expected change in w:tbl count.
+     * Default 0 (no table additions/removals expected).
+     */
+    expectedTableDelta?: number;
+}
+/** Take a snapshot of the body's structural invariants. */
+export declare function captureSnapshot(body: Element): BodySnapshot;
+/**
+ * Compare before / after snapshots.
+ * Throws a descriptive error if any invariant has been violated,
+ * preventing the output file from being written.
+ *
+ * When `expectedChildDelta` is non-zero (structural ops like insert or
+ * delete), signature validation is skipped because the body structure
+ * is *expected* to change.  Child count is still validated against
+ * the expected delta, and table count must remain unchanged.
+ */
+export declare function validateInvariants(before: BodySnapshot, after: BodySnapshot, options?: ValidationOptions): void;

package/dist/tools/docx/validate.js

@@ -0,0 +1,49 @@
+/**
+ * Invariant validation for DOCX write operations.
+ *
+ * Single Responsibility: capture a structural snapshot of w:body and
+ * compare before / after snapshots to guarantee no accidental breakage.
+ */
+import { getBodyChildren, bodySignature, countTables } from './dom.js';
+// ─── Capture ─────────────────────────────────────────────────────────
+/** Take a snapshot of the body's structural invariants. */
+export function captureSnapshot(body) {
+    const children = getBodyChildren(body);
+    return {
+        bodyChildCount: children.length,
+        tableCount: countTables(children),
+        signature: bodySignature(children),
+    };
+}
+// ─── Validate ────────────────────────────────────────────────────────
+/**
+ * Compare before / after snapshots.
+ * Throws a descriptive error if any invariant has been violated,
+ * preventing the output file from being written.
+ *
+ * When `expectedChildDelta` is non-zero (structural ops like insert or
+ * delete), signature validation is skipped because the body structure
+ * is *expected* to change.  Child count is still validated against
+ * the expected delta, and table count must remain unchanged.
+ */
+export function validateInvariants(before, after, options) {
+    const delta = options?.expectedChildDelta ?? 0;
+    const tableDelta = options?.expectedTableDelta ?? 0;
+    const expectedChildCount = before.bodyChildCount + delta;
+    const expectedTableCount = before.tableCount + tableDelta;
+    const errors = [];
+    if (expectedChildCount !== after.bodyChildCount) {
+        errors.push(`Body child count mismatch: expected ${expectedChildCount} (before ${before.bodyChildCount} + delta ${delta}), got ${after.bodyChildCount}`);
+    }
+    if (expectedTableCount !== after.tableCount) {
+        errors.push(`Table count mismatch: expected ${expectedTableCount} (before ${before.tableCount} + delta ${tableDelta}), got ${after.tableCount}`);
+    }
+    // Only enforce signature stability when no structural ops changed the body
+    if (delta === 0 && before.signature !== after.signature) {
+        errors.push(`Body signature changed:\n  before: ${before.signature}\n  after:  ${after.signature}`);
+    }
+    if (errors.length > 0) {
+        throw new Error('DOCX structural validation failed — output NOT written.\n' +
+            errors.join('\n'));
+    }
+}

package/dist/tools/docx/validators.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DOCX Validation Utilities
+ *
+ * Input validation for paths, operations arrays, and image dimensions.
+ *
+ * @module docx/validators
+ */
+/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
+export declare function validateDocxPath(path: string): void;
+/** Validate that an operations array is a non-empty array. */
+export declare function validateOperations(operations: unknown[]): void;
+/** Validate optional image width and height (must be positive and finite). */
+export declare function validateImageDimensions(width?: number, height?: number): void;

package/dist/tools/docx/validators.js

@@ -0,0 +1,40 @@
+/**
+ * DOCX Validation Utilities
+ *
+ * Input validation for paths, operations arrays, and image dimensions.
+ *
+ * @module docx/validators
+ */
+import { DocxError, DocxErrorCode } from './errors.js';
+import { isDocxPath } from './utils/paths.js';
+/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
+export function validateDocxPath(path) {
+    if (!path || typeof path !== 'string') {
+        throw new DocxError('DOCX path must be a non-empty string', DocxErrorCode.INVALID_PATH, { path });
+    }
+    const normalised = path.trim();
+    if (!normalised) {
+        throw new DocxError('DOCX path cannot be empty', DocxErrorCode.INVALID_PATH, { path });
+    }
+    if (!isDocxPath(normalised)) {
+        throw new DocxError('Invalid DOCX path: must end with .docx', DocxErrorCode.INVALID_PATH, { path: normalised });
+    }
+}
+/** Validate that an operations array is a non-empty array. */
+export function validateOperations(operations) {
+    if (!Array.isArray(operations)) {
+        throw new DocxError('Operations must be an array', DocxErrorCode.OPERATION_FAILED, { operations });
+    }
+    if (operations.length === 0) {
+        throw new DocxError('Operations array cannot be empty', DocxErrorCode.OPERATION_FAILED, { operations });
+    }
+}
+/** Validate optional image width and height (must be positive and finite). */
+export function validateImageDimensions(width, height) {
+    if (width !== undefined && (typeof width !== 'number' || width <= 0 || !Number.isFinite(width))) {
+        throw new DocxError('Image width must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { width });
+    }
+    if (height !== undefined && (typeof height !== 'number' || height <= 0 || !Number.isFinite(height))) {
+        throw new DocxError('Image height must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { height });
+    }
+}

package/dist/tools/docx/write.d.ts

@@ -0,0 +1,17 @@
+/**
+ * writeDocxPatched - the patch-based "update" orchestrator.
+ *
+ * Single Responsibility: coordinate the full update pipeline:
+ *   1. Open DOCX ZIP
+ *   2. Parse word/document.xml
+ *   3. Snapshot before
+ *   4. Apply operations (pass zip for ops that touch auxiliary files)
+ *   5. Snapshot after
+ *   6. Validate invariants (accounting for structural deltas)
+ *   7. Serialize and save
+ *
+ * Each step delegates to a single-purpose module, keeping this file
+ * a pure orchestrator with no direct DOM/XML/ZIP logic.
+ */
+import type { DocxOp, WriteDocxResult } from './types.js';
+export declare function writeDocxPatched(inputPath: string, outputPath: string, ops: DocxOp[]): Promise<WriteDocxResult>;

package/dist/tools/docx/write.js

@@ -0,0 +1,88 @@
+/**
+ * writeDocxPatched - the patch-based "update" orchestrator.
+ *
+ * Single Responsibility: coordinate the full update pipeline:
+ *   1. Open DOCX ZIP
+ *   2. Parse word/document.xml
+ *   3. Snapshot before
+ *   4. Apply operations (pass zip for ops that touch auxiliary files)
+ *   5. Snapshot after
+ *   6. Validate invariants (accounting for structural deltas)
+ *   7. Serialize and save
+ *
+ * Each step delegates to a single-purpose module, keeping this file
+ * a pure orchestrator with no direct DOM/XML/ZIP logic.
+ */
+import { loadDocxZip, getDocumentXml, saveDocxZip } from './zip.js';
+import { parseXml, serializeXml, getBody } from './dom.js';
+import { captureSnapshot, validateInvariants } from './validate.js';
+import { applyOp } from './ops/index.js';
+/** Structural op types that add/remove body children. */
+const STRUCTURAL_INSERT_OPS = new Set([
+    'insert_paragraph_after_text',
+    'insert_table',
+    'insert_image',
+]);
+const STRUCTURAL_DELETE_OPS = new Set(['delete_paragraph_at_body_index']);
+export async function writeDocxPatched(inputPath, outputPath, ops) {
+    // 1. Load ZIP
+    const zip = await loadDocxZip(inputPath);
+    // 2. Parse document.xml
+    const xmlStr = getDocumentXml(zip);
+    const doc = parseXml(xmlStr);
+    const body = getBody(doc);
+    // 3. Before-snapshot
+    const before = captureSnapshot(body);
+    // 4. Apply ops — pass zip for ops that modify auxiliary files
+    const results = [];
+    const warnings = [];
+    for (const op of ops) {
+        try {
+            const result = applyOp(body, op, zip);
+            results.push(result);
+            if (result.status === 'skipped') {
+                warnings.push(`Op ${op.type} skipped: ${result.reason ?? 'unknown'}`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`Op ${op.type} failed: ${msg}`);
+            results.push({
+                op,
+                status: 'skipped',
+                matched: 0,
+                reason: `error: ${msg}`,
+            });
+        }
+    }
+    // 5. Compute expected structural delta from applied ops
+    let expectedChildDelta = 0;
+    let expectedTableDelta = 0;
+    for (const r of results) {
+        if (r.status !== 'applied')
+            continue;
+        if (STRUCTURAL_INSERT_OPS.has(r.op.type))
+            expectedChildDelta += 1;
+        if (STRUCTURAL_DELETE_OPS.has(r.op.type))
+            expectedChildDelta -= 1;
+        if (r.op.type === 'insert_table')
+            expectedTableDelta += 1;
+    }
+    // 6. After-snapshot
+    const after = captureSnapshot(body);
+    // 7. Validate — throws if structural invariants are broken
+    validateInvariants(before, after, { expectedChildDelta, expectedTableDelta });
+    // 8. Serialize and save (document.xml + any zip-level changes)
+    const newXml = serializeXml(doc);
+    await saveDocxZip(zip, newXml, outputPath);
+    // 9. Build stats
+    const stats = {
+        tablesBefore: before.tableCount,
+        tablesAfter: after.tableCount,
+        bodyChildrenBefore: before.bodyChildCount,
+        bodyChildrenAfter: after.bodyChildCount,
+        bodySignatureBefore: before.signature,
+        bodySignatureAfter: after.signature,
+    };
+    return { outputPath, results, stats, warnings };
+}

package/dist/tools/docx/zip.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DOCX ZIP I/O — Single Responsibility: file ↔ zip ↔ xml.
+ *
+ * Every other module depends on these three functions for disk I/O;
+ * none of them touch the file system directly.
+ */
+import PizZip from 'pizzip';
+/**
+ * Read a .docx file from disk and return a PizZip instance.
+ */
+export declare function loadDocxZip(filePath: string): Promise<PizZip>;
+/**
+ * Extract the raw XML string from word/document.xml inside the zip.
+ * Throws if the entry is missing.
+ */
+export declare function getDocumentXml(zip: PizZip): string;
+/**
+ * Replace word/document.xml in the zip with new XML,
+ * then write the whole archive to outputPath.
+ */
+export declare function saveDocxZip(zip: PizZip, newDocumentXml: string, outputPath: string): Promise<void>;

package/dist/tools/docx/zip.js

@@ -0,0 +1,35 @@
+/**
+ * DOCX ZIP I/O — Single Responsibility: file ↔ zip ↔ xml.
+ *
+ * Every other module depends on these three functions for disk I/O;
+ * none of them touch the file system directly.
+ */
+import fs from 'fs/promises';
+import PizZip from 'pizzip';
+/**
+ * Read a .docx file from disk and return a PizZip instance.
+ */
+export async function loadDocxZip(filePath) {
+    const buf = await fs.readFile(filePath);
+    return new PizZip(buf);
+}
+/**
+ * Extract the raw XML string from word/document.xml inside the zip.
+ * Throws if the entry is missing.
+ */
+export function getDocumentXml(zip) {
+    const entry = zip.file('word/document.xml');
+    if (!entry) {
+        throw new Error('Invalid DOCX: missing word/document.xml');
+    }
+    return entry.asText();
+}
+/**
+ * Replace word/document.xml in the zip with new XML,
+ * then write the whole archive to outputPath.
+ */
+export async function saveDocxZip(zip, newDocumentXml, outputPath) {
+    zip.file('word/document.xml', newDocumentXml);
+    const buf = zip.generate({ type: 'nodebuffer' });
+    await fs.writeFile(outputPath, buf);
+}

package/dist/tools/schemas.d.ts

@@ -401,3 +401,16 @@ export declare const GetRecentToolCallsArgsSchema: z.ZodObject<{
     toolName?: string | undefined;
     since?: string | undefined;
 }>;
+export declare const TrackUiEventArgsSchema: z.ZodObject<{
+    event: z.ZodString;
+    component: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    params: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>>;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, string | number | boolean | null>;
+    event: string;
+    component: string;
+}, {
+    event: string;
+    params?: Record<string, string | number | boolean | null> | undefined;
+    component?: string | undefined;
+}>;

package/dist/tools/schemas.js

@@ -175,3 +175,8 @@ export const GetRecentToolCallsArgsSchema = z.object({
     toolName: z.string().optional(),
     since: z.string().datetime().optional(),
 });
+export const TrackUiEventArgsSchema = z.object({
+    event: z.string().min(1).max(80),
+    component: z.string().optional().default('file_preview'),
+    params: z.record(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional().default({}),
+});

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import { ChildProcess } from 'child_process';
 import { FilteredStdioServerTransport } from './custom-stdio.js';
+import type { PreviewFileType } from './ui/file-preview/shared/preview-file-types.js';
 declare global {
     var mcpTransport: FilteredStdioServerTransport | undefined;
     var disableOnboarding: boolean | undefined;
@@ -60,8 +61,17 @@ export interface ServerResponseContent {
     data?: string;
     mimeType?: string;
 }
+export interface FilePreviewStructuredContent {
+    fileName: string;
+    filePath: string;
+    fileType: PreviewFileType;
+    content: string;
+    imageData?: string;
+    mimeType?: string;
+}
 export interface ServerResult {
     content: ServerResponseContent[];
+    structuredContent?: FilePreviewStructuredContent | Record<string, unknown>;
     isError?: boolean;
     _meta?: Record<string, unknown>;
 }

package/dist/ui/contracts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Central constants and shape contracts for UI resource identifiers. It gives one source of truth for URIs/tool metadata shared between server handlers and UI loaders.
+ */
+export declare const FILE_PREVIEW_RESOURCE_URI = "ui://desktop-commander/file-preview";
+export declare const CONFIG_EDITOR_RESOURCE_URI = "ui://desktop-commander/config-editor";
+export interface UiToolMeta extends Record<string, unknown> {
+    'ui/resourceUri': string;
+    'openai/outputTemplate': string;
+    ui: {
+        resourceUri: string;
+    };
+    'openai/widgetAccessible'?: boolean;
+}
+export declare function buildUiToolMeta(resourceUri: string, widgetAccessible?: boolean): UiToolMeta;