@hcu-lab.me/mcp-device 1.0.0

package/dist/tools/config.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Get the entire config including system information
+ */
+export declare function getConfig(): Promise<{
+    content: {
+        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
+ */
+export declare function setConfigValue(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/config.js

@@ -0,0 +1,260 @@
+import { configManager } from '../config-manager.js';
+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
+ */
+export async function getConfig() {
+    console.error('getConfig called');
+    try {
+        const config = await configManager.getConfig();
+        // Add system information and current client to the config response
+        const systemInfo = getSystemInfo();
+        // Get memory usage
+        const memoryUsage = process.memoryUsage();
+        const memory = {
+            rss: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`,
+            heapTotal: `${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+            heapUsed: `${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+            external: `${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB`,
+            arrayBuffers: `${(memoryUsage.arrayBuffers / 1024 / 1024).toFixed(2)} MB`
+        };
+        const configWithSystemInfo = {
+            ...config,
+            currentClient,
+            featureFlags: featureFlagManager.getAll(),
+            systemInfo: {
+                ...systemInfo,
+                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) {
+        console.error(`Error in getConfig: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+        // Return empty config rather than crashing
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error getting configuration: ${error instanceof Error ? error.message : String(error)}\nUsing empty configuration.`
+                }],
+        };
+    }
+}
+/**
+ * Set a specific config value
+ */
+export async function setConfigValue(args) {
+    console.error(`setConfigValue called with args: ${JSON.stringify(args)}`);
+    try {
+        const parsed = SetConfigValueArgsSchema.safeParse(args);
+        if (!parsed.success) {
+            console.error(`Invalid arguments for set_config_value: ${parsed.error}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Invalid arguments: ${parsed.error}`
+                    }],
+                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
+            if (typeof valueToStore === 'string' &&
+                (valueToStore.startsWith('[') || valueToStore.startsWith('{'))) {
+                try {
+                    valueToStore = JSON.parse(valueToStore);
+                    console.error(`Parsed string value to object/array: ${JSON.stringify(valueToStore)}`);
+                }
+                catch (parseError) {
+                    console.error(`Failed to parse string as JSON, using as-is: ${parseError}`);
+                }
+            }
+            // Special handling for known array configuration keys
+            if (fieldDefinition.valueType === 'array' && !Array.isArray(valueToStore)) {
+                if (typeof valueToStore === 'string') {
+                    const originalString = valueToStore;
+                    try {
+                        const parsedValue = JSON.parse(originalString);
+                        valueToStore = parsedValue;
+                    }
+                    catch (parseError) {
+                        console.error(`Failed to parse string as array for ${parsed.data.key}: ${parseError}`);
+                        // If parsing failed and it's a single value, convert to an array with one item
+                        if (!originalString.includes('[')) {
+                            valueToStore = [originalString];
+                        }
+                    }
+                }
+                else if (valueToStore !== null) {
+                    // If not a string or array (and not null), convert to an array with one item
+                    valueToStore = [String(valueToStore)];
+                }
+                // Ensure the value is an array after all our conversions
+                if (!Array.isArray(valueToStore)) {
+                    console.error(`Value for ${parsed.data.key} is still not an array, converting to array`);
+                    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();
+            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore, null, 2)}\n\nUpdated configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
+                    }],
+            };
+        }
+        catch (saveError) {
+            console.error(`Error saving config: ${saveError.message}`);
+            // Continue with in-memory change but report error
+            return {
+                content: [{
+                        type: "text",
+                        text: `Value changed in memory but couldn't be saved to disk: ${saveError.message}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (error) {
+        console.error(`Error in setConfigValue: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error setting value: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/tools/edit.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Text file editing via search/replace with fuzzy matching support.
+ *
+ * TECHNICAL DEBT / ARCHITECTURAL NOTE:
+ * This file contains text editing logic that should ideally live in TextFileHandler.editRange()
+ * to be consistent with how Excel editing works (ExcelFileHandler.editRange()).
+ *
+ * Current inconsistency:
+ * - Excel: edit_block → ExcelFileHandler.editRange() ✓ uses file handler
+ * - Text:  edit_block → performSearchReplace() here → bypasses TextFileHandler
+ *
+ * Future refactor should:
+ * 1. Move performSearchReplace() + fuzzy logic into TextFileHandler.editRange()
+ * 2. Make this file a thin dispatch layer that routes to appropriate FileHandler
+ * 3. Unify the editRange() signature to handle both text search/replace and structured edits
+ */
+import { ServerResult } from '../types.js';
+interface SearchReplace {
+    search: string;
+    replace: string;
+}
+export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number, origin?: 'ui' | 'llm'): Promise<ServerResult>;
+/**
+ * Handle edit_block command
+ *
+ * 1. Text files: String replacement (old_string/new_string)
+ *    - Uses fuzzy matching for resilience
+ *    - Handles expected_replacements parameter
+ *
+ * 2. Structured files (Excel): Range rewrite (range + content)
+ *    - Bulk updates to cell ranges (e.g., "Sheet1!A1:C10")
+ *    - Whole sheet replacement (e.g., "Sheet1")
+ *    - More powerful and simpler than surgical location-based edits
+ *    - Supports chunking for large datasets (e.g., 1000 rows at a time)
+
+ */
+export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
+export {};