@wonderwhy-er/desktop-commander 0.1.33 → 0.1.35

package/dist/config-manager.js

@@ -1,242 +1,160 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { CONFIG_FILE } from './config.js';
-import * as process from 'process';
+import { existsSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import os from 'os';
 /**
- * Manages reading and writing server configuration
+ * Singleton config manager for the server
  */
-export class ConfigManager {
+class ConfigManager {
     constructor() {
         this.config = {};
         this.initialized = false;
+        // Get user's home directory
+        const homeDir = os.homedir();
+        // Define config directory and file paths
+        const configDir = path.join(homeDir, '.claude-server-commander');
+        this.configPath = path.join(configDir, 'config.json');
     }
     /**
-     * Load configuration from disk
+     * Initialize configuration - load from disk or create default
      */
-    async loadConfig() {
+    async init() {
+        if (this.initialized)
+            return;
         try {
-            console.error(`Loading config from ${CONFIG_FILE}...`);
-            console.error(`Current working directory: ${process.cwd()}`);
-            console.error(`Absolute config path: ${path.resolve(CONFIG_FILE)}`);
             // Ensure config directory exists
-            const configDir = path.dirname(CONFIG_FILE);
-            try {
-                console.error(`Ensuring config directory exists: ${configDir}`);
-                await fs.mkdir(configDir, { recursive: true });
-                console.error(`Config directory ready: ${configDir}`);
-            }
-            catch (mkdirError) {
-                console.error(`Error creating config directory: ${mkdirError.message}`);
-                // Continue if directory already exists
-                if (mkdirError.code !== 'EEXIST') {
-                    throw mkdirError;
-                }
-            }
-            // Check if the directory exists and is writable
-            try {
-                const dirStats = await fs.stat(configDir);
-                console.error(`Config directory exists: ${dirStats.isDirectory()}`);
-                await fs.access(configDir, fs.constants.W_OK);
-                console.error(`Directory ${configDir} is writable`);
-            }
-            catch (dirError) {
-                console.error(`Config directory check error: ${dirError.message}`);
-            }
-            // Check file permissions
-            try {
-                const fileStats = await fs.stat(CONFIG_FILE).catch(() => null);
-                if (fileStats) {
-                    console.error(`Config file exists, permissions: ${fileStats.mode.toString(8)}`);
-                }
-                else {
-                    console.error('Config file does not exist, will create');
-                }
-            }
-            catch (statError) {
-                console.error(`Error checking file stats: ${statError.message}`);
+            const configDir = path.dirname(this.configPath);
+            if (!existsSync(configDir)) {
+                await mkdir(configDir, { recursive: true });
             }
-            let configData;
+            // Check if config file exists
             try {
-                configData = await fs.readFile(CONFIG_FILE, 'utf-8');
-                console.error(`Config file read successfully, content length: ${configData.length}`);
-            }
-            catch (readError) {
-                console.error(`Error reading config file: ${readError.message}, code: ${readError.code}, stack: ${readError.stack}`);
-                if (readError.code === 'ENOENT') {
-                    console.error('Config file does not exist, will create default');
-                }
-                else {
-                    throw readError;
-                }
-            }
-            if (configData) {
-                try {
-                    this.config = JSON.parse(configData);
-                    console.error(`Config parsed successfully: ${JSON.stringify(this.config, null, 2)}`);
-                }
-                catch (parseError) {
-                    console.error(`Failed to parse config JSON: ${parseError.message}`);
-                    // If file exists but has invalid JSON, use default empty config
-                    this.config = {};
-                }
-            }
-            else {
-                // If file doesn't exist, use default empty config
-                this.config = {};
-            }
-            this.initialized = true;
-            // Create default config file if it doesn't exist
-            if (!configData) {
-                console.error('Creating default config file');
+                await fs.access(this.configPath);
+                // Load existing config
+                const configData = await fs.readFile(this.configPath, 'utf8');
+                this.config = JSON.parse(configData);
+            }
+            catch (error) {
+                // Config file doesn't exist, create default
+                this.config = this.getDefaultConfig();
                 await this.saveConfig();
             }
+            this.initialized = true;
         }
         catch (error) {
-            console.error(`Unexpected error in loadConfig: ${error instanceof Error ? error.message : String(error)}`);
-            console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-            // Initialize with empty config
-            this.config = {};
-            this.initialized = true; // Mark as initialized even with empty config
+            console.error('Failed to initialize config:', error);
+            // Fall back to default config in memory
+            this.config = this.getDefaultConfig();
+            this.initialized = true;
         }
-        return this.config;
     }
     /**
-     * Save current configuration to disk
+     * Alias for init() to maintain backward compatibility
+     */
+    async loadConfig() {
+        return this.init();
+    }
+    /**
+     * Create default configuration
+     */
+    getDefaultConfig() {
+        return {
+            blockedCommands: [
+                // Disk and partition management
+                "mkfs", // Create a filesystem on a device
+                "format", // Format a storage device (cross-platform)
+                "mount", // Mount a filesystem
+                "umount", // Unmount a filesystem
+                "fdisk", // Manipulate disk partition tables
+                "dd", // Convert and copy files, can write directly to disks
+                "parted", // Disk partition manipulator
+                "diskpart", // Windows disk partitioning utility
+                // System administration and user management
+                "sudo", // Execute command as superuser
+                "su", // Substitute user identity
+                "passwd", // Change user password
+                "adduser", // Add a user to the system
+                "useradd", // Create a new user
+                "usermod", // Modify user account
+                "groupadd", // Create a new group
+                "chsh", // Change login shell
+                "visudo", // Edit the sudoers file
+                // System control
+                "shutdown", // Shutdown the system
+                "reboot", // Restart the system
+                "halt", // Stop the system
+                "poweroff", // Power off the system
+                "init", // Change system runlevel
+                // Network and security
+                "iptables", // Linux firewall administration
+                "firewall", // Generic firewall command
+                "netsh", // Windows network configuration
+                // Windows system commands
+                "sfc", // System File Checker
+                "bcdedit", // Boot Configuration Data editor
+                "reg", // Windows registry editor
+                "net", // Network/user/service management
+                "sc", // Service Control manager
+                "runas", // Execute command as another user
+                "cipher", // Encrypt/decrypt files or wipe data
+                "takeown" // Take ownership of files
+            ],
+            defaultShell: os.platform() === 'win32' ? 'powershell.exe' : 'bash',
+            allowedDirectories: []
+        };
+    }
+    /**
+     * Save config to disk
      */
     async saveConfig() {
         try {
-            console.error(`Saving config to ${CONFIG_FILE}...`);
-            console.error(`Current working directory: ${process.cwd()}`);
-            console.error(`Absolute config path: ${path.resolve(CONFIG_FILE)}`);
-            // Always try to create the config directory first
-            const configDir = path.dirname(CONFIG_FILE);
-            try {
-                console.error(`Ensuring config directory exists: ${configDir}`);
-                await fs.mkdir(configDir, { recursive: true });
-                console.error(`Config directory ready: ${configDir}`);
-            }
-            catch (mkdirError) {
-                console.error(`Failed to create directory: ${mkdirError.message}`);
-                if (mkdirError.code !== 'EEXIST') {
-                    throw mkdirError;
-                }
-            }
-            // Check directory permissions
-            try {
-                await fs.access(configDir, fs.constants.W_OK);
-                console.error(`Directory ${configDir} is writable`);
-            }
-            catch (accessError) {
-                console.error(`Directory access error: ${accessError.message}`);
-                throw new Error(`Config directory is not writable: ${accessError.message}`);
-            }
-            const configJson = JSON.stringify(this.config, null, 2);
-            console.error(`Config to save: ${configJson}`);
-            try {
-                // Try to write the file with explicit encoding and permissions
-                await fs.writeFile(CONFIG_FILE, configJson, {
-                    encoding: 'utf-8',
-                    mode: 0o644 // Readable/writable by owner, readable by others
-                });
-                console.error('Config saved successfully');
-            }
-            catch (writeError) {
-                console.error(`Write file error: ${writeError.message}, code: ${writeError.code}, stack: ${writeError.stack}`);
-                throw writeError;
-            }
+            await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf8');
         }
         catch (error) {
-            console.error(`Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`);
-            console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-            throw new Error(`Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`);
+            console.error('Failed to save config:', error);
+            throw error;
         }
     }
+    /**
+     * Get the entire config
+     */
+    async getConfig() {
+        await this.init();
+        return { ...this.config };
+    }
     /**
      * Get a specific configuration value
      */
     async getValue(key) {
-        if (!this.initialized) {
-            console.error(`getValue for key "${key}" - loading config first`);
-            await this.loadConfig();
-        }
-        console.error(`Getting value for key "${key}": ${JSON.stringify(this.config[key])}`);
+        await this.init();
         return this.config[key];
     }
     /**
      * Set a specific configuration value
      */
     async setValue(key, value) {
-        console.error(`Setting value for key "${key}": ${JSON.stringify(value)}`);
-        if (!this.initialized) {
-            console.error('setValue - loading config first');
-            await this.loadConfig();
-        }
+        await this.init();
         this.config[key] = value;
         await this.saveConfig();
     }
-    /**
-     * Get the entire configuration object
-     */
-    async getConfig() {
-        if (!this.initialized) {
-            console.error('getConfig - loading config first');
-            await this.loadConfig();
-        }
-        console.error(`Getting full config: ${JSON.stringify(this.config, null, 2)}`);
-        return { ...this.config }; // Return a copy to prevent untracked mutations
-    }
     /**
      * Update multiple configuration values at once
      */
-    async updateConfig(partialConfig) {
-        console.error(`Updating config with: ${JSON.stringify(partialConfig, null, 2)}`);
-        if (!this.initialized) {
-            console.error('updateConfig - loading config first');
-            await this.loadConfig();
-        }
-        this.config = {
-            ...this.config,
-            ...partialConfig
-        };
+    async updateConfig(updates) {
+        await this.init();
+        this.config = { ...this.config, ...updates };
         await this.saveConfig();
         return { ...this.config };
     }
-}
-// Memory-only version that doesn't try to save to filesystem
-class MemoryConfigManager {
-    constructor() {
-        this.config = {};
-        this.initialized = true;
-    }
-    async loadConfig() {
-        console.error('Using memory-only configuration (no filesystem operations)');
-        return this.config;
-    }
-    async saveConfig() {
-        console.error('Memory-only configuration - changes will not persist after restart');
-        // No-op - we don't save to filesystem
-        return;
-    }
-    async getValue(key) {
-        console.error(`Getting memory value for key "${key}": ${JSON.stringify(this.config[key])}`);
-        return this.config[key];
-    }
-    async setValue(key, value) {
-        console.error(`Setting memory value for key "${key}": ${JSON.stringify(value)}`);
-        this.config[key] = value;
-    }
-    async getConfig() {
-        console.error(`Getting full memory config: ${JSON.stringify(this.config, null, 2)}`);
-        return { ...this.config };
-    }
-    async updateConfig(partialConfig) {
-        console.error(`Updating memory config with: ${JSON.stringify(partialConfig, null, 2)}`);
-        this.config = {
-            ...this.config,
-            ...partialConfig
-        };
+    /**
+     * Reset configuration to defaults
+     */
+    async resetConfig() {
+        this.config = this.getDefaultConfig();
+        await this.saveConfig();
         return { ...this.config };
     }
 }
-// Export the appropriate manager based on the environment
+// Export singleton instance
 export const configManager = new ConfigManager();

package/dist/config.js

@@ -1,6 +1,10 @@
 import path from 'path';
-import process from 'process';
-export const CONFIG_FILE = path.join(process.cwd(), 'config.json');
-export const LOG_FILE = path.join(process.cwd(), 'server.log');
-export const ERROR_LOG_FILE = path.join(process.cwd(), 'error.log');
+import os from 'os';
+// Use user's home directory for configuration files
+const USER_HOME = os.homedir();
+const CONFIG_DIR = path.join(USER_HOME, '.claude-server-commander');
+// Paths relative to the config directory
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export const LOG_FILE = path.join(CONFIG_DIR, 'server.log');
+export const ERROR_LOG_FILE = path.join(CONFIG_DIR, 'error.log');
 export const DEFAULT_COMMAND_TIMEOUT = 1000; // milliseconds

package/dist/error-handlers.d.ts

@@ -0,0 +1,7 @@
+import { ServerResult } from './types.js';
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export declare function createErrorResponse(message: string): ServerResult;

package/dist/error-handlers.js

@@ -0,0 +1,15 @@
+import { capture } from "./utils.js";
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export function createErrorResponse(message) {
+    capture('server_request_error', {
+        error: message
+    });
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}

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

@@ -1,27 +1,13 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle block_command command
  */
-export declare function handleBlockCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: boolean;
-    }[];
-}>;
+export declare function handleBlockCommand(args: unknown): Promise<ServerResult>;
 /**
  * Handle unblock_command command
  */
-export declare function handleUnblockCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: boolean;
-    }[];
-}>;
+export declare function handleUnblockCommand(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_blocked_commands command
  */
-export declare function handleListBlockedCommands(): {
-    content: {
-        type: string;
-        text: string;
-    }[];
-};
+export declare function handleListBlockedCommands(): ServerResult;

package/dist/handlers/command-handlers.js

@@ -6,8 +6,12 @@ import { BlockCommandArgsSchema, UnblockCommandArgsSchema } from '../tools/schem
 export async function handleBlockCommand(args) {
     const parsed = BlockCommandArgsSchema.parse(args);
     const blockResult = await commandManager.blockCommand(parsed.command);
+    // Convert boolean result to appropriate message string
+    const message = blockResult
+        ? `Successfully blocked command: ${parsed.command}`
+        : `Command is already blocked: ${parsed.command}`;
     return {
-        content: [{ type: "text", text: blockResult }],
+        content: [{ type: "text", text: message }],
     };
 }
 /**
@@ -16,8 +20,12 @@ export async function handleBlockCommand(args) {
 export async function handleUnblockCommand(args) {
     const parsed = UnblockCommandArgsSchema.parse(args);
     const unblockResult = await commandManager.unblockCommand(parsed.command);
+    // Convert boolean result to appropriate message string
+    const message = unblockResult
+        ? `Successfully unblocked command: ${parsed.command}`
+        : `Command is not blocked or doesn't exist: ${parsed.command}`;
     return {
-        content: [{ type: "text", text: unblockResult }],
+        content: [{ type: "text", text: message }],
     };
 }
 /**
@@ -25,7 +33,11 @@ export async function handleUnblockCommand(args) {
  */
 export function handleListBlockedCommands() {
     const blockedCommands = commandManager.listBlockedCommands();
+    // Create appropriate message based on whether there are blocked commands
+    const message = blockedCommands.length > 0
+        ? `Blocked commands:\n${blockedCommands.join('\n')}`
+        : "No commands are currently blocked.";
     return {
-        content: [{ type: "text", text: blockedCommands.join('\n') }],
+        content: [{ type: "text", text: message }],
     };
 }

package/dist/handlers/edit-search-handlers.d.ts

@@ -1,18 +1,9 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle edit_block command
  */
-export declare function handleEditBlock(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
 /**
  * Handle search_code command
  */
-export declare function handleSearchCode(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleSearchCode(args: unknown): Promise<ServerResult>;

package/dist/handlers/edit-search-handlers.js

@@ -1,17 +1,18 @@
 import { parseEditBlock, performSearchReplace } from '../tools/edit.js';
 import { searchTextInFiles } from '../tools/search.js';
 import { EditBlockArgsSchema, SearchCodeArgsSchema } from '../tools/schemas.js';
-import { withTimeout } from '../utils.js';
+import { capture, withTimeout } from '../utils.js';
+import { createErrorResponse } from '../error-handlers.js';
 /**
  * Handle edit_block command
  */
 export async function handleEditBlock(args) {
     const parsed = EditBlockArgsSchema.parse(args);
-    const { filePath, searchReplace } = await parseEditBlock(parsed.blockContent);
-    await performSearchReplace(filePath, searchReplace);
-    return {
-        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-    };
+    const { filePath, searchReplace, error } = await parseEditBlock(parsed.blockContent);
+    if (error) {
+        return createErrorResponse(error);
+    }
+    return performSearchReplace(filePath, searchReplace);
 }
 /**
  * Handle search_code command
@@ -43,7 +44,9 @@ export async function handleSearchCode(args) {
             delete globalThis.currentSearchProcess;
         }
         catch (error) {
-            console.error('Error terminating search process:', error);
+            capture('server_request_error', {
+                error: 'Error terminating search process'
+            });
         }
     }
     if (results.length === 0) {

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

@@ -1,90 +1,33 @@
+import { ServerResult } from '../types.js';
 /**
  * Handle read_file command
  */
-export declare function handleReadFile(args: unknown): Promise<{
-    content: ({
-        type: string;
-        text: string;
-        data?: undefined;
-        mimeType?: undefined;
-    } | {
-        type: string;
-        data: string;
-        mimeType: string;
-        text?: undefined;
-    })[];
-}>;
+export declare function handleReadFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle read_multiple_files command
  */
-export declare function handleReadMultipleFiles(args: unknown): Promise<{
-    content: {
-        type: string;
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }[];
-}>;
+export declare function handleReadMultipleFiles(args: unknown): Promise<ServerResult>;
 /**
  * Handle write_file command
  */
-export declare function handleWriteFile(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleWriteFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle create_directory command
  */
-export declare function handleCreateDirectory(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleCreateDirectory(args: unknown): Promise<ServerResult>;
 /**
  * Handle list_directory command
  */
-export declare function handleListDirectory(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleListDirectory(args: unknown): Promise<ServerResult>;
 /**
  * Handle move_file command
  */
-export declare function handleMoveFile(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleMoveFile(args: unknown): Promise<ServerResult>;
 /**
  * Handle search_files command
  */
-export declare function handleSearchFiles(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+export declare function handleSearchFiles(args: unknown): Promise<ServerResult>;
 /**
  * Handle get_file_info command
  */
-export declare function handleGetFileInfo(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-/**
- * Handle list_allowed_directories command
- */
-export declare function handleListAllowedDirectories(): {
-    content: {
-        type: string;
-        text: string;
-    }[];
-};
+export declare function handleGetFileInfo(args: unknown): Promise<ServerResult>;