@wonderwhy-er/desktop-commander 0.1.34 → 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.js

@@ -1,9 +1,13 @@
+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/edit-search-handlers.js

@@ -1,24 +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) {
-    try {
-        const parsed = EditBlockArgsSchema.parse(args);
-        const { filePath, searchReplace, error } = await parseEditBlock(parsed.blockContent);
-        if (error) {
-            return createErrorResponse(error);
-        }
-        return performSearchReplace(filePath, searchReplace);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return createErrorResponse(errorMessage);
+    const parsed = EditBlockArgsSchema.parse(args);
+    const { filePath, searchReplace, error } = await parseEditBlock(parsed.blockContent);
+    if (error) {
+        return createErrorResponse(error);
     }
+    return performSearchReplace(filePath, searchReplace);
 }
 /**
  * Handle search_code command
@@ -50,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

@@ -31,7 +31,3 @@ export declare function handleSearchFiles(args: unknown): Promise<ServerResult>;
  * Handle get_file_info command
  */
 export declare function handleGetFileInfo(args: unknown): Promise<ServerResult>;
-/**
- * Handle list_allowed_directories command
- */
-export declare function handleListAllowedDirectories(): ServerResult;

package/dist/handlers/filesystem-handlers.js

@@ -1,4 +1,4 @@
-import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo, listAllowedDirectories } from '../tools/filesystem.js';
+import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo } from '../tools/filesystem.js';
 import { withTimeout } from '../utils.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema } from '../tools/schemas.js';
@@ -21,8 +21,7 @@ export async function handleReadFile(args) {
     const HANDLER_TIMEOUT = 60000; // 60 seconds total operation timeout
     const readFileOperation = async () => {
         const parsed = ReadFileArgsSchema.parse(args);
-        // Explicitly cast the result to FileResult since we're passing true
-        const fileResult = await readFile(parsed.path, true, parsed.isUrl);
+        const fileResult = await readFile(parsed.path, parsed.isUrl);
         if (fileResult.isImage) {
             // For image files, return as an image content type
             return {
@@ -47,9 +46,12 @@ export async function handleReadFile(args) {
         }
     };
     // Execute with timeout at the handler level
-    return await withTimeout(readFileOperation(), HANDLER_TIMEOUT, 'Read file handler operation', {
-        content: [{ type: "text", text: `Operation timed out after ${HANDLER_TIMEOUT / 1000} seconds. The file might be too large or on a slow/unresponsive storage device.` }],
-    });
+    const result = await withTimeout(readFileOperation(), HANDLER_TIMEOUT, 'Read file handler operation', null);
+    if (result == null) {
+        // Handles the impossible case where withTimeout resolves to null instead of throwing
+        throw new Error('Failed to read the file');
+    }
+    return result;
 }
 /**
  * Handle read_multiple_files command
@@ -214,15 +216,5 @@ export async function handleGetFileInfo(args) {
         return createErrorResponse(errorMessage);
     }
 }
-/**
- * Handle list_allowed_directories command
- */
-export function handleListAllowedDirectories() {
-    const directories = listAllowedDirectories();
-    return {
-        content: [{
-                type: "text",
-                text: `Allowed directories:\n${directories.join('\n')}`
-            }],
-    };
-}
+// The listAllowedDirectories function has been removed
+// Use get_config to retrieve the allowedDirectories configuration

package/dist/handlers/index.d.ts

@@ -1,5 +1,4 @@
 export * from './filesystem-handlers.js';
 export * from './terminal-handlers.js';
 export * from './process-handlers.js';
-export * from './command-handlers.js';
 export * from './edit-search-handlers.js';

package/dist/handlers/index.js

@@ -2,5 +2,4 @@
 export * from './filesystem-handlers.js';
 export * from './terminal-handlers.js';
 export * from './process-handlers.js';
-export * from './command-handlers.js';
 export * from './edit-search-handlers.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { FilteredStdioServerTransport } from './custom-stdio.js';
 import { server } from './server.js';
-import { commandManager } from './command-manager.js';
+import { configManager } from './config-manager.js';
 import { join, dirname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { platform } from 'os';
@@ -81,12 +81,25 @@ async function runServer() {
             process.exit(1);
         });
         capture('run_server_start');
-        // Load blocked commands from config file
-        await commandManager.loadBlockedCommands();
+        try {
+            console.error("Loading configuration...");
+            await configManager.loadConfig();
+            console.error("Configuration loaded successfully");
+        }
+        catch (configError) {
+            console.error(`Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            console.error(configError instanceof Error && configError.stack ? configError.stack : 'No stack trace available');
+            console.error("Continuing with in-memory configuration only");
+            // Continue anyway - we'll use an in-memory config
+        }
+        console.error("Connecting server...");
         await server.connect(transport);
+        console.error("Server connected successfully");
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`FATAL ERROR: ${errorMessage}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
         process.stderr.write(JSON.stringify({
             type: 'error',
             timestamp: new Date().toISOString(),
@@ -100,6 +113,8 @@ async function runServer() {
 }
 runServer().catch(async (error) => {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`RUNTIME ERROR: ${errorMessage}`);
+    console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
     process.stderr.write(JSON.stringify({
         type: 'error',
         timestamp: new Date().toISOString(),

package/dist/sandbox/index.d.ts

@@ -0,0 +1,9 @@
+import { CommandExecutionResult } from '../types.js';
+/**
+ * Platform detection and sandbox execution router
+ */
+export declare function executeSandboxedCommand(command: string, timeoutMs?: number, shell?: string): Promise<CommandExecutionResult>;
+/**
+ * Check if sandboxed execution is available for the current platform
+ */
+export declare function isSandboxAvailable(): boolean;

package/dist/sandbox/index.js

@@ -0,0 +1,50 @@
+import os from 'os';
+import { executeSandboxedCommand as macExecuteSandboxedCommand } from './mac-sandbox.js';
+import { configManager } from '../config-manager.js';
+/**
+ * Platform detection and sandbox execution router
+ */
+export async function executeSandboxedCommand(command, timeoutMs = 30000, shell) {
+    // Get the allowed directories from config
+    const config = await configManager.getConfig();
+    const allowedDirectories = config.allowedDirectories || [os.homedir()];
+    const platform = os.platform();
+    // Platform-specific sandbox execution
+    switch (platform) {
+        case 'darwin': // macOS
+            try {
+                const result = await macExecuteSandboxedCommand(command, allowedDirectories, timeoutMs);
+                return {
+                    pid: result.pid,
+                    output: result.output,
+                    isBlocked: result.isBlocked
+                };
+            }
+            catch (error) {
+                console.error('Mac sandbox execution error:', error);
+                return {
+                    pid: -1,
+                    output: `Sandbox execution error: ${error instanceof Error ? error.message : String(error)}`,
+                    isBlocked: false
+                };
+            }
+        // Add cases for other platforms when implemented
+        // case 'linux':
+        // case 'win32':
+        default:
+            // For unsupported platforms, return an error
+            return {
+                pid: -1,
+                output: `Sandbox execution not supported on ${platform}. Command was not executed: ${command}`,
+                isBlocked: false
+            };
+    }
+}
+/**
+ * Check if sandboxed execution is available for the current platform
+ */
+export function isSandboxAvailable() {
+    const platform = os.platform();
+    // Currently only implemented for macOS
+    return platform === 'darwin';
+}

package/dist/sandbox/mac-sandbox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generate a temporary sandbox profile for macOS that restricts access to allowed directories
+ * @param allowedDirectories Array of directories that should be accessible
+ * @returns Path to the generated sandbox profile file
+ */
+export declare function generateSandboxProfile(allowedDirectories: string[]): Promise<string>;
+/**
+ * Execute a command in a macOS sandbox with access restricted to allowed directories
+ * @param command Command to execute
+ * @param allowedDirectories Array of allowed directory paths
+ * @param options Additional execution options
+ * @returns Promise resolving to the execution result
+ */
+export declare function executeSandboxedCommand(command: string, allowedDirectories: string[], timeoutMs?: number): Promise<{
+    output: string;
+    exitCode: number | null;
+    isBlocked: boolean;
+    pid: number;
+}>;