@wonderwhy-er/desktop-commander 0.2.37 → 0.2.39

package/dist/config-manager.js

@@ -5,6 +5,22 @@ import { mkdir } from 'fs/promises';
 import os from 'os';
 import { VERSION } from './version.js';
 import { CONFIG_FILE } from './config.js';
+export function normalizeTelemetryEnabledValue(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') {
+        return true;
+    }
+    if (normalized === 'false') {
+        return false;
+    }
+    return value;
+}
+export function isTelemetryDisabledValue(value) {
+    return normalizeTelemetryEnabledValue(value) === false;
+}
 /**
  * Singleton config manager for the server
  */
@@ -154,12 +170,16 @@ class ConfigManager {
      */
     async setValue(key, value) {
         await this.init();
+        if (key === 'telemetryEnabled') {
+            value = normalizeTelemetryEnabledValue(value);
+        }
         // Special handling for telemetry opt-out
-        if (key === 'telemetryEnabled' && value === false) {
+        if (key === 'telemetryEnabled' && isTelemetryDisabledValue(value)) {
             // Get the current value before changing it
             const currentValue = this.config[key];
+            const telemetryAlreadyDisabled = isTelemetryDisabledValue(currentValue);
             // Only capture the opt-out event if telemetry was previously enabled
-            if (currentValue !== false) {
+            if (!telemetryAlreadyDisabled) {
                 // Import the capture function dynamically to avoid circular dependencies
                 const { capture } = await import('./utils/capture.js');
                 // Send a final telemetry event noting that the user has opted out

package/dist/handlers/filesystem-handlers.d.ts

@@ -1,4 +1,9 @@
 import { ServerResult } from '../types.js';
+/**
+ * Resolve a file path to an absolute path for use in structured content.
+ * This ensures "Open in folder" always has a valid absolute path.
+ */
+export declare function resolveAbsolutePath(filePath: string): string;
 /**
  * Handle read_file command
  */

package/dist/handlers/filesystem-handlers.js

@@ -5,7 +5,6 @@ import { configManager } from '../config-manager.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, WritePdfArgsSchema } from '../tools/schemas.js';
 import path from 'path';
 import os from 'os';
-import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from '../ui/contracts.js';
 import { resolvePreviewFileType } from '../ui/file-preview/shared/preview-file-types.js';
 /**
  * Expand home directory (~) in a file path
@@ -20,7 +19,7 @@ function expandHome(filePath) {
  * Resolve a file path to an absolute path for use in structured content.
  * This ensures "Open in folder" always has a valid absolute path.
  */
-function resolveAbsolutePath(filePath) {
+export function resolveAbsolutePath(filePath) {
     const expanded = expandHome(filePath);
     return path.isAbsolute(expanded)
         ? path.resolve(expanded)
@@ -100,9 +99,7 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'unsupported',
-                    content: ''
                 },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         // Handle image files
@@ -124,28 +121,26 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'image',
-                    content: imageSummary,
                     imageData,
                     mimeType: fileResult.mimeType
-                },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
+                }
             };
         }
         else {
-            // For all other files, return as text
+            // For all other files, return as text.
+            // structuredContent carries only file metadata (no content duplication);
+            // the widget reads text from the MCP content array.
             const textContent = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('utf8');
-            const previewFileType = resolvePreviewFileType(resolvedFilePath);
+            const fileType = fileResult.metadata?.isDirectory ? 'directory' : resolvePreviewFileType(resolvedFilePath);
             return {
                 content: [{ type: "text", text: textContent }],
                 structuredContent: {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
-                    fileType: previewFileType,
-                    content: textContent
+                    fileType,
                 },
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
     };
@@ -241,11 +236,17 @@ export async function handleWriteFile(args) {
         await writeFile(parsed.path, parsed.content, parsed.mode);
         // Provide more informative message based on mode
         const modeMessage = parsed.mode === 'append' ? 'appended to' : 'wrote to';
+        const resolvedWritePath = resolveAbsolutePath(parsed.path);
         return {
             content: [{
                     type: "text",
                     text: `Successfully ${modeMessage} ${parsed.path} (${lineCount} lines) ${errorMessage}`
                 }],
+            structuredContent: {
+                fileName: path.basename(resolvedWritePath),
+                filePath: resolvedWritePath,
+                fileType: resolvePreviewFileType(resolvedWritePath),
+            },
         };
     }
     catch (error) {
@@ -279,8 +280,14 @@ export async function handleListDirectory(args) {
         const entries = await listDirectory(parsed.path, parsed.depth);
         const duration = Date.now() - startTime;
         const resultText = entries.join('\n');
+        const resolvedPath = resolveAbsolutePath(parsed.path);
         return {
             content: [{ type: "text", text: resultText }],
+            structuredContent: {
+                fileName: path.basename(resolvedPath),
+                filePath: resolvedPath,
+                fileType: 'directory',
+            },
         };
     }
     catch (error) {

package/dist/remote-device/desktop-commander-integration.js

@@ -76,7 +76,7 @@ export class DesktopCommanderIntegration {
                 // We can't run it directly as it's an stdio MCP server that waits for input
                 const whichCommand = process.platform === 'win32' ? 'where' : 'which';
                 console.debug('[DEBUG] Using platform command:', whichCommand, 'on platform:', process.platform);
-                const check = spawn(whichCommand, [commandName]);
+                const check = spawn(whichCommand, [commandName], { windowsHide: true }); // Prevent visible console windows on Windows
                 check.on('error', (err) => {
                     console.debug('[DEBUG] Spawn error for', whichCommand, ':', err.message);
                     reject(err);

package/dist/remote-device/remote-channel.js

@@ -126,7 +126,7 @@ export class RemoteChannel {
             console.debug(`⏳ Subscribing to tool call channel...`);
             // Create and subscribe to the channel
             console.debug('[DEBUG] Calling createChannel()');
-            // ! Ignore silently in Inialization to reconnect after
+            // ! Ignore silently in Initialization to reconnect after
             await this.createChannel().catch((error) => {
                 console.debug('[DEBUG] Failed to create channel, will retry after socket reconnect', error);
             });

package/dist/search-manager.js

@@ -33,7 +33,7 @@ import PizZip from 'pizzip';
             throw new Error(`Failed to locate ripgrep binary: ${err instanceof Error ? err.message : String(err)}`);
         }
         // Start ripgrep process
-        const rgProcess = spawn(rgPath, args);
+        const rgProcess = spawn(rgPath, args, { windowsHide: true }); // Prevent visible console windows on Windows
         if (!rgProcess.pid) {
             throw new Error('Failed to start ripgrep process');
         }
@@ -94,7 +94,8 @@ import PizZip from 'pizzip';
         const shouldSearchExcel = options.searchType === 'content' &&
             this.shouldIncludeExcelSearch(options.filePattern, validPath);
         if (shouldSearchExcel) {
-            this.searchExcelFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern // Pass filePattern to filter Excel files too
+            this.searchExcelFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern, // Pass filePattern to filter Excel files too
+            options.literalSearch // Respect literalSearch flag for Office files
             ).then(excelResults => {
                 // Add Excel results to session (merged after initial response)
                 for (const result of excelResults) {
@@ -110,7 +111,8 @@ import PizZip from 'pizzip';
         const shouldSearchDocx = options.searchType === 'content' &&
             this.shouldIncludeDocxSearch(options.filePattern, validPath);
         if (shouldSearchDocx) {
-            this.searchDocxFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern).then(docxResults => {
+            this.searchDocxFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern, options.literalSearch // Respect literalSearch flag for Office files
+            ).then(docxResults => {
                 for (const result of docxResults) {
                     session.results.push(result);
                     session.totalMatches++;
@@ -223,19 +225,11 @@ import PizZip from 'pizzip';
      * and inject into SearchManager, similar to how file handlers are structured in src/utils/files/
      * This would allow adding other file type searches (PDF, etc.) without bloating search-manager.ts
      */
-    async searchExcelFiles(rootPath, pattern, ignoreCase, maxResults, filePattern) {
+    async searchExcelFiles(rootPath, pattern, ignoreCase, maxResults, filePattern, _literalSearch) {
         const results = [];
-        // Build regex for matching content
-        const flags = ignoreCase ? 'i' : '';
-        let regex;
-        try {
-            regex = new RegExp(pattern, flags);
-        }
-        catch {
-            // If pattern is not valid regex, escape it for literal matching
-            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            regex = new RegExp(escaped, flags);
-        }
+        // Office file search always uses literal matching to prevent ReDoS.
+        // Regex patterns are treated as literal strings — this is intentional.
+        const searchTerm = ignoreCase ? pattern.toLowerCase() : pattern;
         // Find Excel files recursively
         let excelFiles = await this.findExcelFiles(rootPath);
         // Filter by filePattern if provided
@@ -246,7 +240,13 @@ import PizZip from 'pizzip';
                 return patterns.some(pat => {
                     // Support glob-like patterns
                     if (pat.includes('*')) {
-                        const regexPat = pat.replace(/\./g, '\\.').replace(/\*/g, '.*');
+                        // Escape all regex metacharacters first (preserving * for glob expansion),
+                        // then convert the remaining * wildcards to .* for glob matching.
+                        // Without this, patterns like report(2024).xlsx or [draft].xlsx would be
+                        // misinterpreted as regex groups/character-classes.
+                        const regexPat = pat
+                            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape metacharacters except *
+                            .replace(/\*/g, '.*'); // glob * → regex .*
                         return new RegExp(`^${regexPat}$`, 'i').test(fileName);
                     }
                     // Exact match (case-insensitive)
@@ -300,12 +300,10 @@ import PizZip from 'pizzip';
                         });
                         // Join all cell values with space for cross-column matching
                         const rowText = rowValues.join(' ');
-                        if (regex.test(rowText)) {
-                            // Extract the matching portion for display
-                            const match = rowText.match(regex);
-                            const matchContext = match
-                                ? this.getMatchContext(rowText, match.index || 0, match[0].length)
-                                : rowText.substring(0, 150);
+                        const textToSearch = ignoreCase ? rowText.toLowerCase() : rowText;
+                        const matchIndex = textToSearch.indexOf(searchTerm);
+                        if (matchIndex !== -1) {
+                            const matchContext = this.getMatchContext(rowText, matchIndex, searchTerm.length);
                             results.push({
                                 file: `${filePath}:${sheetName}!Row${rowNumber}`,
                                 line: rowNumber,
@@ -386,17 +384,11 @@ import PizZip from 'pizzip';
      * Search DOCX files for content matches
      * Extracts <w:t> text from document.xml and searches it
      */
-    async searchDocxFiles(rootPath, pattern, ignoreCase, maxResults, filePattern) {
+    async searchDocxFiles(rootPath, pattern, ignoreCase, maxResults, filePattern, _literalSearch) {
         const results = [];
-        const flags = ignoreCase ? 'i' : '';
-        let regex;
-        try {
-            regex = new RegExp(pattern, flags);
-        }
-        catch {
-            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            regex = new RegExp(escaped, flags);
-        }
+        // Office file search always uses literal matching to prevent ReDoS.
+        // Regex patterns are treated as literal strings — this is intentional.
+        const searchTerm = ignoreCase ? pattern.toLowerCase() : pattern;
         let docxFiles = await this.findDocxFiles(rootPath);
         if (filePattern) {
             const patterns = filePattern.split('|').map(p => p.trim()).filter(Boolean);
@@ -404,7 +396,9 @@ import PizZip from 'pizzip';
                 const fileName = path.basename(filePath);
                 return patterns.some(pat => {
                     if (pat.includes('*')) {
-                        const regexPat = pat.replace(/\./g, '\\.').replace(/\*/g, '.*');
+                        const regexPat = pat
+                            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape metacharacters except *
+                            .replace(/\*/g, '.*'); // glob * → regex .*
                         return new RegExp(`^${regexPat}$`, 'i').test(fileName);
                     }
                     return fileName.toLowerCase() === pat.toLowerCase();
@@ -438,11 +432,10 @@ import PizZip from 'pizzip';
                         if (!text || !text.trim())
                             continue;
                         lineNum++;
-                        if (regex.test(text)) {
-                            const match = text.match(regex);
-                            const matchContext = match
-                                ? this.getMatchContext(text, match.index || 0, match[0].length)
-                                : text.substring(0, 150);
+                        const textToSearch = ignoreCase ? text.toLowerCase() : text;
+                        const matchIndex = textToSearch.indexOf(searchTerm);
+                        if (matchIndex !== -1) {
+                            const matchContext = this.getMatchContext(text, matchIndex, searchTerm.length);
                             const partName = xmlPath === 'word/document.xml' ? '' : `:${xmlPath.replace('word/', '')}`;
                             results.push({
                                 file: `${filePath}${partName}`,

package/dist/server.js

@@ -21,7 +21,7 @@ import { handleWelcomePageOnboarding } from './utils/welcome-onboarding.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
-import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
+import { buildUiToolMeta, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
 import { listUiResources, readUiResource } from './ui/resources.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
@@ -137,9 +137,11 @@ deferLog('info', 'Setting up request handlers...');
  * Check if a tool should be included based on current client
  */
 function shouldIncludeTool(toolName) {
-    // Exclude give_feedback_to_desktop_commander for desktop-commander client
-    if (toolName === 'give_feedback_to_desktop_commander' && currentClient?.name === 'desktop-commander') {
-        return false;
+    // Exclude these tools for desktop-commander client (DC-specific meta-tools not useful when DC itself is the client)
+    if (currentClient?.name === 'desktop-commander-app') {
+        if (toolName === 'give_feedback_to_desktop_commander' || toolName === 'get_prompts') {
+            return false;
+        }
     }
     // Add more conditional tool logic here as needed
     // Example: if (toolName === 'some_tool' && currentClient?.name === 'some_client') return false;
@@ -167,6 +169,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true),
                 annotations: {
                     title: "Get Configuration",
                     readOnlyHint: true,
@@ -327,6 +330,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
                 annotations: {
                     title: "Write File",
                     readOnlyHint: false,
@@ -446,6 +450,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
                 annotations: {
                     title: "List Directory Contents",
                     readOnlyHint: true,
@@ -704,6 +709,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
                 annotations: {
                     title: "Edit Block",
                     readOnlyHint: false,
@@ -1104,6 +1110,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
             telemetryData.set_config_value_key_name = args.key;
+            telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
         }
         if (name === 'get_prompts' && args && typeof args === 'object') {
             const promptArgs = args;

package/dist/terminal-manager.js

@@ -119,7 +119,8 @@ export class TerminalManager {
                 env: {
                     ...process.env,
                     TERM: 'xterm-256color' // Better terminal compatibility
-                }
+                },
+                windowsHide: true // Prevent visible console windows on Windows
             };
             // Add shell option if needed (for unknown shells)
             if (spawnConfig.useShellOption) {
@@ -138,7 +139,8 @@ export class TerminalManager {
                 env: {
                     ...process.env,
                     TERM: 'xterm-256color'
-                }
+                },
+                windowsHide: true // Prevent visible console windows on Windows
             };
         }
         // Spawn the process with appropriate arguments

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();