feat(terminal): implement advanced shell command safety check #335

- Rewrite safety check using PSI (Program Structure Interface) to accurately parse and analyze shell commands
- Add new dangerous patterns and improve existing ones- Introduce helper functions for better code organization and readability
- Update TerminalSketchProvider to use the new safety check- Add unit tests for ShellSyntaxSafetyCheck to ensure correctness

Author: phodal

exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/ShellSyntaxSafetyCheck.kt

@@ -1,34 +1,96 @@
 package cc.unitmesh.terminal.sketch
 
-object ShellSyntaxSafetyCheck {
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFileFactory
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.sh.ShLanguage
+import com.intellij.sh.psi.ShCommand
+import com.intellij.sh.psi.ShFile
 
+object ShellSyntaxSafetyCheck {
     /**
      * Check if shell command contains dangerous operations
      * @return Pair<Boolean, String> - first: is dangerous, second: reason message
      */
-    fun checkDangerousCommand(command: String): Pair<Boolean, String> {
-        val dangerousPatterns = mapOf(
-            "\\brm\\s+(-[a-zA-Z]*f|-[a-zA-Z]*r|-[a-zA-Z]*(rf|fr))\\b.*".toRegex() to "Dangerous rm command with recursive or force flags",
-            "\\brm\\s+-[a-zA-Z]*\\s+/\\b.*".toRegex() to "Removing files from root directory",
-            "\\brmdir\\s+/\\b.*".toRegex() to "Removing directories from root",
-            "\\bmkfs\\b.*".toRegex() to "Filesystem formatting command",
-            "\\bdd\\b.*".toRegex() to "Low-level disk operation",
-            "\\b:[(][)][{]\\s*:|:&\\s*[}];:.*".toRegex() to "Potential fork bomb",
-            "\\bchmod\\s+-[a-zA-Z]*R\\b.*777\\b.*".toRegex() to "Recursive chmod with insecure permissions",
-            "\\bsudo\\s+rm\\b.*".toRegex() to "Removing files with elevated privileges",
-        )
-
-        // Also catch simpler rm commands (without flags but still potentially dangerous)
-        if (command.trim().startsWith("rm ") && !command.contains("-i") && !command.contains("--interactive")) {
-            return Pair(true, "Remove command detected, use with caution")
-        }
+    fun checkDangerousCommand(project: Project, command: String): Pair<Boolean, String> {
+        val psiFile = PsiFileFactory.getInstance(project)
+            .createFileFromText("temp.sh", ShLanguage.INSTANCE, command) as? ShFile
+            ?: return Pair(true, "Could not parse command")
 
-        for ((pattern, message) in dangerousPatterns) {
-            if (pattern.containsMatchIn(command)) {
-                return Pair(true, message)
+        val commandElements = PsiTreeUtil.findChildrenOfType(psiFile, ShCommand::class.java)
+
+        for (cmd in commandElements) {
+            if (isDangerousRmCommand(cmd)) {
+                return Pair(true, "Dangerous rm command detected")
             }
+
+            if (isSudoCommand(cmd)) {
+                val sudoArgs = getSudoArgs(cmd)
+                if (sudoArgs.contains("rm")) {
+                    return Pair(true, "Removing files with elevated privileges")
+                }
+            }
+
+            if (isCommandWithName(cmd, "mkfs")) {
+                return Pair(true, "Filesystem formatting command")
+            }
+
+            if (isCommandWithName(cmd, "dd")) {
+                return Pair(true, "Low-level disk operation")
+            }
+
+            if (isCommandWithName(cmd, "chmod") && hasRecursiveFlag(cmd) && hasInsecurePermissions(cmd)) {
+                return Pair(true, "Recursive chmod with insecure permissions")
+            }
+
+            if (operatesOnRootDirectory(cmd)) {
+                return Pair(true, "Operation targeting root directory")
+            }
+        }
+
+        if (command.contains(":(){ :|:& };:") || command.matches(".*:[(][)][{]\\s*:|:&\\s*[}];:.*".toRegex())) {
+            return Pair(true, "Potential fork bomb")
         }
 
         return Pair(false, "")
     }
+
+    private fun isDangerousRmCommand(command: ShCommand): Boolean {
+        if (!isCommandWithName(command, "rm")) return false
+
+        val options = getCommandOptions(command)
+        return options.contains("-rf") || options.contains("-fr") ||
+                options.contains("-r") && options.contains("-f") ||
+                options.contains("-f") && !options.contains("-i")
+    }
+
+    private fun isSudoCommand(command: ShCommand): Boolean {
+        return isCommandWithName(command, "sudo")
+    }
+
+    private fun getSudoArgs(cmd: ShCommand): List<String> {
+        return cmd.text.trim().split("\\s+".toRegex()).drop(1)
+    }
+
+    private fun getCommandOptions(cmd: ShCommand): List<String> {
+        return cmd.text.trim().split("\\s+".toRegex()).filter { it.startsWith("-") }
+    }
+
+    private fun isCommandWithName(cmd: ShCommand, name: String): Boolean {
+        val tokens = cmd.text.trim().split("\\s+".toRegex())
+        return tokens.firstOrNull() == name
+    }
+
+    private fun hasRecursiveFlag(cmd: ShCommand): Boolean {
+        return getCommandOptions(cmd).any { it.matches("-[rR]+".toRegex()) }
+    }
+
+    private fun hasInsecurePermissions(cmd: ShCommand): Boolean {
+        return cmd.text.contains("777")
+    }
+
+    private fun operatesOnRootDirectory(cmd: ShCommand): Boolean {
+        val tokens = cmd.text.trim().split("\\s+".toRegex())
+        return tokens.any { it == "/" }
+    }
 }

exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/TerminalSketchProvider.kt

@@ -267,7 +267,7 @@ class TerminalLangSketch(val project: Project, var content: String) : ExtensionL
         codeSketch.updateViewText(code, true)
         titleLabel.text = "Terminal - ($content)"
 
-        val (isDangerous, reason) = ShellSyntaxSafetyCheck.checkDangerousCommand(content)
+        val (isDangerous, reason) = ShellSyntaxSafetyCheck.checkDangerousCommand(project, content)
         if (isDangerous) {
             AutoDevNotifications.notify(project, "Auto-execution has been disabled for safety: $reason")
 

exts/ext-terminal/src/test/kotlin/cc/unitmesh/terminal/sketch/ShellSyntaxSafetyCheckTest.kt

@@ -0,0 +1,44 @@
+package cc.unitmesh.terminal.sketch
+
+import com.intellij.testFramework.fixtures.BasePlatformTestCase
+
+class ShellSyntaxSafetyCheckTest : BasePlatformTestCase() {
+    fun testCheckDangerousCommandByPsi() {
+        val project = project // Use the test fixture's project
+
+        // Test safe commands
+        val safeCommands = listOf(
+            "ls -la",
+            "cd /home/user",
+            "echo 'Hello World'"
+        )
+
+        for (command in safeCommands) {
+            val result = ShellSyntaxSafetyCheck.checkDangerousCommandByPsi(project, command)
+            assertFalse("Should be safe: $command", result.first)
+            assertEquals("", result.second)
+        }
+
+        // Test dangerous commands
+        val dangerousCommands = mapOf(
+            "rm -rf /tmp" to "Dangerous rm command detected",
+            "sudo rm file.txt" to "Removing files with elevated privileges",
+            "mkfs /dev/sda1" to "Filesystem formatting command",
+            "dd if=/dev/zero of=/dev/sda" to "Low-level disk operation",
+            "chmod -R 777 /var" to "Recursive chmod with insecure permissions",
+            "rm /" to "Operation targeting root directory"
+        )
+
+        for ((command, expectedMessage) in dangerousCommands) {
+            val result = ShellSyntaxSafetyCheck.checkDangerousCommandByPsi(project, command)
+            assertTrue("Should be dangerous: $command", result.first)
+            assertEquals(expectedMessage, result.second)
+        }
+
+        // Test fork bomb
+        val forkBomb = ":(){ :|:& };:"
+        val result = ShellSyntaxSafetyCheck.checkDangerousCommandByPsi(project, forkBomb)
+        assertTrue("Fork bomb should be detected", result.first)
+        assertEquals("Potential fork bomb", result.second)
+    }
+}