@wonderwhy-er/desktop-commander 0.2.36 → 0.2.38

package/dist/tools/config.d.ts

@@ -6,6 +6,77 @@ export declare function getConfig(): Promise<{
         type: string;
         text: string;
     }[];
+    structuredContent: {
+        config: {
+            currentClient: {
+                name: string;
+                version: string;
+            };
+            featureFlags: Record<string, any>;
+            systemInfo: {
+                memory: {
+                    rss: string;
+                    heapTotal: string;
+                    heapUsed: string;
+                    external: string;
+                    arrayBuffers: string;
+                };
+                platform: string;
+                platformName: string;
+                defaultShell: string;
+                pathSeparator: string;
+                isWindows: boolean;
+                isMacOS: boolean;
+                isLinux: boolean;
+                docker: import("../utils/system-info.js").ContainerInfo;
+                isDXT: boolean;
+                nodeInfo?: {
+                    version: string;
+                    path: string;
+                    npmVersion?: string;
+                };
+                pythonInfo?: {
+                    available: boolean;
+                    command: string;
+                    version?: string;
+                };
+                processInfo: {
+                    pid: number;
+                    arch: string;
+                    platform: string;
+                    versions: NodeJS.ProcessVersions;
+                };
+                examplePaths: {
+                    home: string;
+                    temp: string;
+                    absolute: string;
+                    accessible?: string[];
+                };
+            };
+            blockedCommands?: string[];
+            defaultShell?: string;
+            allowedDirectories?: string[];
+            telemetryEnabled?: boolean;
+            fileWriteLineLimit?: number;
+            fileReadLineLimit?: number;
+            clientId?: string;
+        };
+        uiHints: {
+            availableShells: string[];
+        };
+        entries: {
+            key: "defaultShell" | "blockedCommands" | "allowedDirectories" | "telemetryEnabled" | "fileReadLineLimit" | "fileWriteLineLimit";
+            value: unknown;
+            valueType: "string" | "number" | "boolean" | "array";
+            editable: boolean;
+        }[];
+    };
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    structuredContent?: undefined;
 }>;
 /**
  * Set a specific config value

package/dist/tools/config.js

@@ -3,6 +3,74 @@ import { SetConfigValueArgsSchema } from './schemas.js';
 import { getSystemInfo } from '../utils/system-info.js';
 import { currentClient } from '../server.js';
 import { featureFlagManager } from '../utils/feature-flags.js';
+import { access, readFile } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { CONFIG_FIELD_DEFINITIONS, CONFIG_FIELD_KEYS, isConfigFieldKey, } from '../config-field-definitions.js';
+const ALLOWED_CONFIG_KEYS = new Set(CONFIG_FIELD_KEYS);
+async function pathExists(pathValue) {
+    try {
+        await access(pathValue, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectAvailableShells(systemInfo) {
+    const detected = new Set();
+    const add = (shell) => {
+        if (shell.trim().length > 0) {
+            detected.add(shell.trim());
+        }
+    };
+    add(systemInfo.defaultShell);
+    if (systemInfo.isWindows) {
+        add(process.env.ComSpec ?? '');
+        const systemRoot = process.env.SystemRoot ?? 'C:\\Windows';
+        const candidates = [
+            `${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`,
+            `${systemRoot}\\System32\\cmd.exe`,
+            `${systemRoot}\\System32\\bash.exe`,
+            'powershell.exe',
+            'pwsh.exe',
+            'cmd.exe',
+            'bash.exe',
+        ];
+        for (const shell of candidates) {
+            if (shell.includes('\\')) {
+                if (await pathExists(shell)) {
+                    add(shell);
+                }
+            }
+            else {
+                add(shell);
+            }
+        }
+        return [...detected];
+    }
+    add(process.env.SHELL ?? '');
+    const shellFiles = ['/etc/shells'];
+    for (const shellFile of shellFiles) {
+        try {
+            const content = await readFile(shellFile, 'utf8');
+            content
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith('#'))
+                .forEach(add);
+        }
+        catch {
+            // Best-effort discovery only.
+        }
+    }
+    const fallbackCandidates = ['/bin/zsh', '/bin/bash', '/bin/sh', '/usr/bin/fish'];
+    for (const shell of fallbackCandidates) {
+        if (await pathExists(shell)) {
+            add(shell);
+        }
+    }
+    return [...detected];
+}
 /**
  * Get the entire config including system information
  */
@@ -30,12 +98,29 @@ export async function getConfig() {
                 memory
             }
         };
+        const availableShells = await detectAvailableShells(systemInfo);
         console.error(`getConfig result: ${JSON.stringify(configWithSystemInfo, null, 2)}`);
         return {
             content: [{
                     type: "text",
                     text: `Current configuration:\n${JSON.stringify(configWithSystemInfo, null, 2)}`
                 }],
+            structuredContent: {
+                config: configWithSystemInfo,
+                uiHints: {
+                    availableShells,
+                },
+                entries: CONFIG_FIELD_KEYS.map((key) => {
+                    const definition = CONFIG_FIELD_DEFINITIONS[key];
+                    const value = configWithSystemInfo[key];
+                    return {
+                        key,
+                        value,
+                        valueType: definition.valueType,
+                        editable: true,
+                    };
+                }),
+            },
         };
     }
     catch (error) {
@@ -67,7 +152,17 @@ export async function setConfigValue(args) {
                 isError: true
             };
         }
+        if (!isConfigFieldKey(parsed.data.key)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Key "${parsed.data.key}" is not configurable via this tool. Allowed keys: ${[...ALLOWED_CONFIG_KEYS].join(', ')}`
+                    }],
+                isError: true
+            };
+        }
         try {
+            const fieldDefinition = CONFIG_FIELD_DEFINITIONS[parsed.data.key];
             // Parse string values that should be arrays or objects
             let valueToStore = parsed.data.value;
             // If the value is a string that looks like an array or object, try to parse it
@@ -82,8 +177,7 @@ export async function setConfigValue(args) {
                 }
             }
             // Special handling for known array configuration keys
-            if ((parsed.data.key === 'allowedDirectories' || parsed.data.key === 'blockedCommands') &&
-                !Array.isArray(valueToStore)) {
+            if (fieldDefinition.valueType === 'array' && !Array.isArray(valueToStore)) {
                 if (typeof valueToStore === 'string') {
                     const originalString = valueToStore;
                     try {
@@ -108,6 +202,27 @@ export async function setConfigValue(args) {
                     valueToStore = [String(valueToStore)];
                 }
             }
+            // Harden boolean fields against stringly-typed inputs like "false".
+            if (fieldDefinition.valueType === 'boolean') {
+                if (typeof valueToStore === 'string') {
+                    const normalized = valueToStore.trim().toLowerCase();
+                    if (normalized === 'true') {
+                        valueToStore = true;
+                    }
+                    else if (normalized === 'false') {
+                        valueToStore = false;
+                    }
+                }
+                if (typeof valueToStore !== 'boolean') {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Value for ${parsed.data.key} must be boolean true/false.`
+                            }],
+                        isError: true
+                    };
+                }
+            }
             await configManager.setValue(parsed.data.key, valueToStore);
             // Get the updated configuration to show the user
             const updatedConfig = await configManager.getConfig();

package/dist/tools/docx/builders/table.d.ts

@@ -1,8 +1,10 @@
 /**
  * Table builder — creates w:tbl elements with headers, rows, and styling.
+ * Supports multiple paragraphs per cell with different styles.
  */
 import type { DocxContentTable, InsertTableOp } from '../types.js';
 /**
  * Build a table element from content structure or operation.
+ * Supports cells with multiple paragraphs, each with its own style.
  */
 export declare function buildTable(doc: Document, spec: DocxContentTable | InsertTableOp): Element;

package/dist/tools/docx/builders/table.js

@@ -1,8 +1,11 @@
 /**
  * Table builder — creates w:tbl elements with headers, rows, and styling.
+ * Supports multiple paragraphs per cell with different styles.
  */
+import { buildParagraph } from './paragraph.js';
 /**
  * Build a table element from content structure or operation.
+ * Supports cells with multiple paragraphs, each with its own style.
  */
 export function buildTable(doc, spec) {
     const tbl = doc.createElement('w:tbl');
@@ -29,12 +32,13 @@ export function buildTable(doc, spec) {
     }
     tblPr.appendChild(tblBorders);
     tbl.appendChild(tblPr);
-    // Table grid
+    // Determine column count
     const colCount = spec.headers
         ? spec.headers.length
         : spec.rows.length > 0
             ? spec.rows[0].length
             : 0;
+    // Table grid
     if (colCount > 0) {
         const tblGrid = doc.createElement('w:tblGrid');
         for (let c = 0; c < colCount; c++) {
@@ -45,9 +49,15 @@ export function buildTable(doc, spec) {
         }
         tbl.appendChild(tblGrid);
     }
-    // Helper to build a cell
-    const buildCell = (text, isHeader, widthTwips) => {
+    /**
+     * Build a cell from content.
+     * Content can be:
+     * - A string: creates one paragraph with that text
+     * - An array of DocxContentParagraph: creates multiple paragraphs, each with its own style
+     */
+    const buildCell = (content, isHeader, widthTwips) => {
         const tc = doc.createElement('w:tc');
+        // Cell properties (width)
         if (widthTwips) {
             const tcPr = doc.createElement('w:tcPr');
             const tcW = doc.createElement('w:tcW');
@@ -56,20 +66,54 @@ export function buildTable(doc, spec) {
             tcPr.appendChild(tcW);
             tc.appendChild(tcPr);
         }
-        const p = doc.createElement('w:p');
-        const r = doc.createElement('w:r');
-        if (isHeader) {
-            const rPr = doc.createElement('w:rPr');
-            const b = doc.createElement('w:b');
-            rPr.appendChild(b);
-            r.appendChild(rPr);
+        // Handle content: string or array of paragraphs
+        if (typeof content === 'string') {
+            // Simple case: single paragraph
+            const p = doc.createElement('w:p');
+            const r = doc.createElement('w:r');
+            // Header cells get bold
+            if (isHeader) {
+                const rPr = doc.createElement('w:rPr');
+                const b = doc.createElement('w:b');
+                rPr.appendChild(b);
+                r.appendChild(rPr);
+            }
+            const t = doc.createElement('w:t');
+            t.setAttribute('xml:space', 'preserve');
+            t.textContent = content;
+            r.appendChild(t);
+            p.appendChild(r);
+            tc.appendChild(p);
+        }
+        else {
+            // Complex case: multiple paragraphs with different styles
+            for (const paraSpec of content) {
+                const p = buildParagraph(doc, paraSpec);
+                // If header and first paragraph, ensure bold on runs
+                if (isHeader) {
+                    const runs = p.getElementsByTagName('w:r');
+                    for (let i = 0; i < runs.length; i++) {
+                        const run = runs.item(i);
+                        let rPr = run.getElementsByTagName('w:rPr').item(0);
+                        if (!rPr) {
+                            rPr = doc.createElement('w:rPr');
+                            if (run.firstChild) {
+                                run.insertBefore(rPr, run.firstChild);
+                            }
+                            else {
+                                run.appendChild(rPr);
+                            }
+                        }
+                        // Add bold if not already present
+                        if (!rPr.getElementsByTagName('w:b').length) {
+                            const b = doc.createElement('w:b');
+                            rPr.appendChild(b);
+                        }
+                    }
+                }
+                tc.appendChild(p);
+            }
         }
-        const t = doc.createElement('w:t');
-        t.setAttribute('xml:space', 'preserve');
-        t.textContent = text;
-        r.appendChild(t);
-        p.appendChild(r);
-        tc.appendChild(p);
         return tc;
     };
     // Header row

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

@@ -23,6 +23,17 @@ export declare function getBody(doc: Document): Element;
  * Includes w:p, w:tbl, w:sdt, w:sectPr, etc.
  */
 export declare function getBodyChildren(body: Element): Element[];
+/**
+ * Return ALL top‑level tables that are logically in the body, including those
+ * wrapped in structured document tags (w:sdt / w:sdtContent).
+ *
+ * Previous logic only saw tables that were direct children of <w:body>. That
+ * meant tables inside SDTs were invisible to table operations and readDocxOutline.
+ * This helper walks the body tree and collects any <w:tbl> that appears as a
+ * *first‑class* block (we do not recurse into tables themselves, so nested
+ * tables are not double‑counted).
+ */
+export declare function getAllBodyTables(body: Element): Element[];
 /**
  * Build a compact signature string from the body children array.
  * Maps each node's qualified name to a short local name:
@@ -34,13 +45,75 @@ export declare function bodySignature(children: Element[]): string;
 export declare function getParagraphText(p: Element): string;
 /** Read the style id from w:pPr/w:pStyle/@w:val, or null if absent. */
 export declare function getParagraphStyle(p: Element): string | null;
+/**
+ * Extract all text content from a table cell (w:tc).
+ * Returns the concatenated text from all paragraphs in the cell.
+ */
+export declare function getCellText(tc: Element): string;
+/**
+ * Extract all rows from a table (w:tbl).
+ * Returns an array of rows, where each row is an array of cell text strings.
+ * First row is treated as header if it exists.
+ */
+export declare function getTableContent(tbl: Element): {
+    headers?: string[];
+    rows: string[][];
+};
+/**
+ * Get table style from w:tblPr/w:tblStyle/@w:val, or null if absent.
+ */
+export declare function getTableStyle(tbl: Element): string | null;
+/**
+ * Extract image reference from a w:drawing element.
+ * Returns the relationship ID (rId) and media file path if found.
+ */
+export declare function getImageReference(drawing: Element): {
+    rId: string | null;
+    mediaPath: string | null;
+};
 /**
  * Replace the text of a paragraph with minimal DOM changes.
  * Sets the FIRST w:t to `text`, clears every subsequent w:t.
  * Sets xml:space="preserve" so leading/trailing spaces survive.
- * Does NOT recreate runs or remove paragraph properties.
+ * Does NOT remove/recreate runs or remove paragraph properties.
+ *
+ * WARNING: This function does NOT preserve multiple runs with different styles.
+ * Use setParagraphTextPreservingStyles() for cells with multiple styled runs.
  */
 export declare function setParagraphTextMinimal(p: Element, text: string): void;
+/**
+ * Replace paragraph text while preserving all run styles.
+ *
+ * This function preserves the structure of all runs (w:r) and their
+ * properties (w:rPr), distributing the new text across existing runs.
+ *
+ * Strategy:
+ * 1. Collect all runs with their properties
+ * 2. Distribute new text across runs (preserving run count and styles)
+ * 3. If new text is longer, extend the last run
+ * 4. If new text is shorter, clear excess runs but keep their structure
+ */
+export declare function setParagraphTextPreservingStyles(p: Element, text: string): void;
+/**
+ * Replace cell text while preserving ALL paragraphs and their styles.
+ *
+ * This function works at the cell level:
+ * - Preserves ALL paragraphs in the cell (doesn't remove any)
+ * - Updates text in the first paragraph while preserving its styles
+ * - Keeps all other paragraphs intact with their original text and styles
+ *
+ * This ensures that cells with multiple paragraphs (each with different
+ * styles, font sizes, etc.) maintain their structure after text replacement.
+ *
+ * Example: If a cell has:
+ *   - Paragraph 1: "LAWN AND LANDSCAPE" (Heading1 style, large font, red color)
+ *   - Paragraph 2: "Take your weekends back..." (Normal style, smaller font, black color)
+ *
+ * Replacing with "EARTH AND MOUNTAIN" will:
+ *   - Update paragraph 1 to "EARTH AND MOUNTAIN" (preserving Heading1 style, large font, red color)
+ *   - Keep paragraph 2 completely intact with its original text and style
+ */
+export declare function setCellTextPreservingStyles(tc: Element, text: string): void;
 /**
  * Ensure a <w:r> element has w:rPr/w:color[@w:val=hex].
  * Creates w:rPr and w:color if they don't exist.