Feature/destructive safety

src/config-manager.ts

@@ -10,6 +10,9 @@ export interface ServerConfig {
   blockedCommands?: string[];
   defaultShell?: string;
   allowedDirectories?: string[];
+  readOnlyDirectories?: string[]; // Directories that can be read but not modified
+  requireExplicitPermission?: boolean; // Require explicit flag for destructive commands
+  allowedSudoCommands?: string[]; // Whitelist of allowed sudo commands with pattern support
   telemetryEnabled?: boolean; // New field for telemetry control
   fileWriteLineLimit?: number; // Line limit for file write operations
   fileReadLineLimit?: number; // Default line limit for file read operations (changed from character-based)
@@ -131,6 +134,9 @@ class ConfigManager {
       ],
       defaultShell: os.platform() === 'win32' ? 'powershell.exe' : '/bin/sh',
       allowedDirectories: [],
+      readOnlyDirectories: [], // Empty by default - no directories are read-only
+      requireExplicitPermission: false, // Default to false for backward compatibility
+      allowedSudoCommands: [], // Empty array allows no sudo commands by default
       telemetryEnabled: true, // Default to opt-out approach (telemetry on by default)
       fileWriteLineLimit: 50,  // Default line limit for file write operations (changed from 100)
       fileReadLineLimit: 1000  // Default line limit for file read operations (changed from character-based)

src/terminal-manager.ts

@@ -5,6 +5,32 @@ import { configManager } from './config-manager.js';
 import {capture} from "./utils/capture.js";
 import { analyzeProcessState } from './utils/process-detection.js';
 
+// The permission flag for destructive commands
+const PERMISSION_FLAG = '--i-have-explicit-permission-from-user';
+
+// Patterns for destructive commands
+const DESTRUCTIVE_PATTERNS = [
+    /\brm\s+(-rf?|-fr?)\s+/,       // rm -rf or rm -fr
+    /\brm\s+.*\*/,                  // rm with wildcards
+    /\bfind\s+.*-delete/,           // find with -delete
+    /\bfind\s+.*-exec\s+rm/,        // find with -exec rm
+    /\b(dd|mkfs|format|fdisk)\b/,   // Disk operations
+];
+
+/**
+ * Check if a command is destructive and needs explicit permission
+ */
+function isDestructiveCommand(command: string): boolean {
+    return DESTRUCTIVE_PATTERNS.some(pattern => pattern.test(command));
+}
+
+/**
+ * Check if command has permission flag
+ */
+function hasPermissionFlag(command: string): boolean {
+    return command.includes(PERMISSION_FLAG);
+}
+
 interface CompletedSession {
   pid: number;
   output: string;
@@ -44,6 +70,35 @@ export class TerminalManager {
   }
 
   async executeCommand(command: string, timeoutMs: number = DEFAULT_COMMAND_TIMEOUT, shell?: string): Promise<CommandExecutionResult> {
+    // Check for destructive commands if protection is enabled
+    try {
+      const config = await configManager.getConfig();
+      if (config.requireExplicitPermission !== false) { // Default to true if not set
+        if (isDestructiveCommand(command) && !hasPermissionFlag(command)) {
+          return {
+            pid: -1,
+            output: `🚨 DESTRUCTIVE OPERATION BLOCKED! 🚨
+
+This command requires explicit permission.
+To execute, you MUST:
+1. Ask the user what specifically they want deleted
+2. Show them what will be affected
+3. Get explicit confirmation
+4. Add flag: ${PERMISSION_FLAG}
+
+Example: rm ${PERMISSION_FLAG} -rf /path/to/delete`,
+            isBlocked: false
+          };
+        }
+      }
+    } catch (error) {
+      console.error('Error checking destructive command protection:', error);
+      // Continue execution if config check fails
+    }
+
+    // Remove the permission flag before executing
+    const cleanCommand = command.replace(PERMISSION_FLAG, '').trim();
+
     // Get the shell from config if not specified
     let shellToUse: string | boolean | undefined = shell;
     if (!shellToUse) {
@@ -60,9 +115,9 @@ export class TerminalManager {
     // Note: No special stdio options needed here, Node.js handles pipes by default
 
     // Enhance SSH commands automatically
-    let enhancedCommand = command;
-    if (command.trim().startsWith('ssh ') && !command.includes(' -t')) {
-      enhancedCommand = command.replace(/^ssh /, 'ssh -t ');
+    let enhancedCommand = cleanCommand;
+    if (cleanCommand.trim().startsWith('ssh ') && !cleanCommand.includes(' -t')) {
+      enhancedCommand = cleanCommand.replace(/^ssh /, 'ssh -t ');
       console.log(`Enhanced SSH command: ${enhancedCommand}`);
     }
 

src/tools/filesystem.ts

@@ -214,16 +214,47 @@ async function isPathAllowed(pathToCheck: string): Promise<boolean> {
     return isAllowed;
 }
 
+/**
+ * Check if a path is within a read-only directory
+ * @param checkPath The path to check
+ * @returns Promise<boolean> True if the path is read-only
+ */
+async function isPathReadOnly(checkPath: string): Promise<boolean> {
+    const config = await configManager.getConfig();
+    const readOnlyDirs = config.readOnlyDirectories || [];
+
+    if (readOnlyDirs.length === 0) {
+        return false; // No read-only directories configured
+    }
+
+    const normalizedCheckPath = path.normalize(checkPath).toLowerCase();
+
+    for (const dir of readOnlyDirs) {
+        const expandedDir = expandHome(dir);
+        const normalizedDir = path.normalize(expandedDir).toLowerCase();
+
+        // Check if the path is within the read-only directory
+        if (normalizedCheckPath === normalizedDir || 
+            normalizedCheckPath.startsWith(normalizedDir + path.sep)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Validates a path to ensure it can be accessed or created.
  * For existing paths, returns the real path (resolving symlinks).
  * For non-existent paths, validates parent directories to ensure they exist.
+ * For write operations, also checks if the path is read-only.
  *
  * @param requestedPath The path to validate
+ * @param isWriteOperation Whether this is a write operation (default: false)
  * @returns Promise<string> The validated path
- * @throws Error if the path or its parent directories don't exist or if the path is not allowed
+ * @throws Error if the path or its parent directories don't exist or if the path is not allowed or read-only
  */
-export async function validatePath(requestedPath: string): Promise<string> {
+export async function validatePath(requestedPath: string, isWriteOperation: boolean = false): Promise<string> {
     const validationOperation = async (): Promise<string> => {
         // Expand home directory if present
         const expandedPath = expandHome(requestedPath);
@@ -243,6 +274,16 @@ export async function validatePath(requestedPath: string): Promise<string> {
             throw new Error(`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
         }
 
+        // Check if path is read-only for write operations
+        if (isWriteOperation && await isPathReadOnly(absolute)) {
+            capture('server_path_validation_error', {
+                error: 'Path is read-only',
+                operation: 'write'
+            });
+
+            throw new Error(`Path is read-only: ${requestedPath}. This directory is protected from modifications.`);
+        }
+
         // Check if path exists
         try {
             const stats = await fs.stat(absolute);
@@ -828,7 +869,7 @@ function splitLinesPreservingEndings(content: string): string[] {
 }
 
 export async function writeFile(filePath: string, content: string, mode: 'rewrite' | 'append' = 'rewrite'): Promise<void> {
-    const validPath = await validatePath(filePath);
+    const validPath = await validatePath(filePath, true); // Mark as write operation
 
     // Get file extension for telemetry
     const fileExtension = getFileExtension(validPath);
@@ -886,7 +927,7 @@ export async function readMultipleFiles(paths: string[]): Promise<MultiFileResul
 }
 
 export async function createDirectory(dirPath: string): Promise<void> {
-    const validPath = await validatePath(dirPath);
+    const validPath = await validatePath(dirPath, true); // Creating directory is a write operation
     await fs.mkdir(validPath, { recursive: true });
 }
 
@@ -897,8 +938,8 @@ export async function listDirectory(dirPath: string): Promise<string[]> {
 }
 
 export async function moveFile(sourcePath: string, destinationPath: string): Promise<void> {
-    const validSourcePath = await validatePath(sourcePath);
-    const validDestPath = await validatePath(destinationPath);
+    const validSourcePath = await validatePath(sourcePath, true); // Source needs write permission (to delete)
+    const validDestPath = await validatePath(destinationPath, true); // Destination needs write permission
     await fs.rename(validSourcePath, validDestPath);
 }
 

test-destructive.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// Test script for destructive command safety rails
+
+import { TerminalManager } from './dist/terminal-manager.js';
+import { configManager } from './dist/config-manager.js';
+
+async function testDestructiveCommandProtection() {
+    console.log('Testing destructive command safety rails...\n');
+
+    const manager = new TerminalManager();
+
+    // Enable protection (it's enabled by default)
+    await configManager.init();
+    await configManager.setValue('requireExplicitPermission', true);
+
+    console.log('✅ Protection enabled\n');
+
+    // Test 1: Try rm -rf without permission flag
+    console.log('Test 1: rm -rf without permission flag');
+    const result1 = await manager.executeCommand('rm -rf /tmp/test-dir', 1000);
+    if (result1.output.includes('DESTRUCTIVE OPERATION BLOCKED')) {
+        console.log('✅ Command correctly blocked\n');
+    } else {
+        console.log('❌ ERROR: Command was not blocked!\n');
+    }
+
+    // Test 2: Try rm -rf WITH permission flag
+    console.log('Test 2: rm -rf WITH permission flag');
+    const result2 = await manager.executeCommand('rm --i-have-explicit-permission-from-user -rf /tmp/test-dir', 1000);
+    if (!result2.output.includes('DESTRUCTIVE OPERATION BLOCKED')) {
+        console.log('✅ Command allowed with permission flag\n');
+    } else {
+        console.log('❌ ERROR: Command was blocked even with flag!\n');
+    }
+
+    // Test 3: Try find with -delete
+    console.log('Test 3: find with -delete');
+    const result3 = await manager.executeCommand('find /tmp -name "*.log" -delete', 1000);
+    if (result3.output.includes('DESTRUCTIVE OPERATION BLOCKED')) {
+        console.log('✅ find -delete correctly blocked\n');
+    } else {
+        console.log('❌ ERROR: find -delete was not blocked!\n');
+    }
+
+    // Test 4: Normal commands should work
+    console.log('Test 4: Normal command (ls)');
+    const result4 = await manager.executeCommand('ls /tmp', 1000);
+    if (!result4.output.includes('DESTRUCTIVE OPERATION BLOCKED')) {
+        console.log('✅ Normal command allowed\n');
+    } else {
+        console.log('❌ ERROR: Normal command was blocked!\n');
+    }
+
+    console.log('✅ Destructive command protection test complete!');
+
+    // Clean up
+    manager.forceTerminate();
+}
+
+testDestructiveCommandProtection().catch(console.error);

test-readonly.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+// Test script for read-only directory protection
+
+import { configManager } from './dist/config-manager.js';
+import { writeFile } from './dist/tools/filesystem.js';
+
+async function testReadOnlyProtection() {
+    console.log('Testing read-only directory protection...\n');
+
+    // Set up a read-only directory within allowed paths
+    await configManager.init();
+    await configManager.setValue('readOnlyDirectories', ['/home/konverts/projects2/test-readonly']);
+
+    console.log('✅ Configuration set: /home/konverts/projects2/test-readonly is now read-only\n');
+
+    // Try to write to a read-only directory
+    try {
+        console.log('Attempting to write to /home/konverts/projects2/test-readonly/test.txt...');
+        await writeFile('/home/konverts/projects2/test-readonly/test.txt', 'This should fail');
+        console.log('❌ ERROR: Write succeeded when it should have failed!');
+    } catch (error) {
+        console.log('✅ Write correctly blocked:', error.message);
+    }
+
+    // Try to write to a non-protected directory
+    try {
+        console.log('\nAttempting to write to /home/konverts/projects2/test-allowed/test.txt...');
+        await writeFile('/home/konverts/projects2/test-allowed/test.txt', 'This should work');
+        console.log('✅ Write succeeded to non-protected directory');
+    } catch (error) {
+        console.log('❌ ERROR: Write failed:', error.message);
+    }
+
+    console.log('\n✅ Read-only protection test complete!');
+}
+
+testReadOnlyProtection().catch(console.error);