feat(devtools): improve shell command execution and output display

phodal · phodal · commit f0296126943d · 2025-03-21T10:45:52.000+08:00
- Refactor ProcessExecutor to return a structured result object- Update ShellRunService to handle execution results more effectively
- Enhance TerminalSketchProvider to display and format execution results
- Improve CollapsiblePanel functionality for better UI interaction
diff --git a/core/src/main/kotlin/cc/unitmesh/devti/sketch/run/ProcessExecutor.kt b/core/src/main/kotlin/cc/unitmesh/devti/sketch/run/ProcessExecutor.kt
@@ -43,16 +43,22 @@ import java.io.Writer
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.TimeUnit
 
+data class ProcessExecutorResult(
+    val exitCode: Int,
+    val stdOutput: String,
+    val errOutput: String
+)
+
 class ProcessExecutor(val project: Project) {
-    fun executeCode(code: String): String? {
+    fun executeCode(code: String): ProcessExecutorResult {
         val taskExecutor = PooledThreadExecutor.INSTANCE
-        val future: CompletableFuture<String?> = CompletableFuture()
+        val future: CompletableFuture<ProcessExecutorResult> = CompletableFuture()
         val task = object : Task.Backgroundable(project, "Running shell command") {
             override fun run(indicator: ProgressIndicator) {
                 runBlocking(taskExecutor.asCoroutineDispatcher()) {
                     val executor = ProcessExecutor(project)
                     val result = executor.executeCode(code, taskExecutor.asCoroutineDispatcher())
-                    future.complete(result ?: "")
+                    future.complete(result)
                 }
             }
         }
@@ -63,7 +69,7 @@ class ProcessExecutor(val project: Project) {
         return future.get(120, TimeUnit.SECONDS)
     }
 
-    suspend fun executeCode(code: String, dispatcher: CoroutineDispatcher): String? {
+    suspend fun executeCode(code: String, dispatcher: CoroutineDispatcher): ProcessExecutorResult {
         val outputWriter = StringWriter()
         val errWriter = StringWriter()
 
@@ -72,15 +78,19 @@ class ProcessExecutor(val project: Project) {
             val stdOutput = outputWriter.toString()
             val errOutput = errWriter.toString()
 
-            return if (exitCode == 0) {
+            if (exitCode == 0) {
                 AutoDevNotifications.notify(project, "Shell command $code executed successfully")
-                stdOutput
             } else {
                 AutoDevToolWindowFactory.Companion.sendToSketchToolWindow(project, ChatActionType.SKETCH) { ui, _ ->
                     ui.putText("Error executing shell command: \n```bash\n$errOutput\n```")
                 }
-                "Error executing shell command: $errOutput"
             }
+
+            return ProcessExecutorResult(
+                exitCode = exitCode,
+                stdOutput = stdOutput,
+                errOutput = errOutput
+            )
         }
     }
 
@@ -178,4 +188,4 @@ class ProcessExecutor(val project: Project) {
             } while (process.isAlive || line != null)
         }
     }
-}
+}
diff --git a/exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/service/ShellRunService.kt b/exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/service/ShellRunService.kt
@@ -8,10 +8,6 @@ import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunProfile
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.runReadAction
-import com.intellij.openapi.progress.ProgressIndicator
-import com.intellij.openapi.progress.ProgressManager
-import com.intellij.openapi.progress.Task
-import com.intellij.openapi.progress.impl.BackgroundableProcessIndicator
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiElement
@@ -20,11 +16,6 @@ import com.intellij.sh.psi.ShFile
 import com.intellij.sh.run.ShConfigurationType
 import com.intellij.sh.run.ShRunConfiguration
 import com.intellij.sh.run.ShRunner
-import kotlinx.coroutines.asCoroutineDispatcher
-import kotlinx.coroutines.runBlocking
-import org.jetbrains.ide.PooledThreadExecutor
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.TimeUnit
 
 class ShellRunService : RunService {
     override fun isApplicable(project: Project, file: VirtualFile) = file.extension == "sh" || file.extension == "bash"
@@ -39,7 +30,13 @@ class ShellRunService : RunService {
 
         val code = virtualFile.readText()
         if (isFromToolAction) {
-            return ProcessExecutor(project).executeCode(code)
+            return ProcessExecutor(project).executeCode(code).let { result ->
+                return if (result.exitCode != 0) {
+                    "Error: ${result.errOutput}"
+                } else {
+                    "Output: ${result.stdOutput}"
+                }
+            }
         }
 
         val shRunner = ApplicationManager.getApplication().getService(ShRunner::class.java)
diff --git a/exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/CollapsiblePanel.kt b/exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/CollapsiblePanel.kt
@@ -10,12 +10,12 @@ import java.awt.event.MouseAdapter
 import java.awt.event.MouseEvent
 import javax.swing.JPanel
 
-class CollapsiblePanel(title: String, content: JPanel, initiallyCollapsed: Boolean = false) :
+class CollapsiblePanel(title: String, private val contentPanel: JPanel, initiallyCollapsed: Boolean = false) :
     JBPanel<CollapsiblePanel>(BorderLayout()) {
 
     private var isCollapsed = initiallyCollapsed
     private val headerPanel = JBPanel<JBPanel<*>>(BorderLayout())
-    private val titleLabel = JBLabel(title)
+    val titleLabel = JBLabel(title)
     private val toggleLabel = JBLabel()
 
     init {
@@ -28,31 +28,47 @@ class CollapsiblePanel(title: String, content: JPanel, initiallyCollapsed: Boole
 
         headerPanel.addMouseListener(object : MouseAdapter() {
             override fun mouseClicked(e: MouseEvent?) {
-                toggleContent(content)
+                toggleContent()
             }
         })
 
         add(headerPanel, BorderLayout.NORTH)
-        add(content, BorderLayout.CENTER)
+        add(contentPanel, BorderLayout.CENTER)
 
-        content.isVisible = !isCollapsed
+        contentPanel.isVisible = !isCollapsed
     }
 
     private fun updateToggleIcon() {
         toggleLabel.icon = if (isCollapsed) AllIcons.General.ArrowRight else AllIcons.General.ArrowDown
     }
 
-    private fun toggleContent(content: JPanel) {
-        setCollapsed(!isCollapsed, content)
+    private fun toggleContent() {
+        setCollapsed(!isCollapsed)
     }
 
-    fun setCollapsed(collapsed: Boolean, content: JPanel) {
+    fun setCollapsed(collapsed: Boolean) {
         isCollapsed = collapsed
-        content.isVisible = !isCollapsed
+        contentPanel.isVisible = !isCollapsed
         updateToggleIcon()
         revalidate()
         repaint()
     }
 
+    fun setCollapsed(collapsed: Boolean, content: JPanel) {
+        setCollapsed(collapsed)
+    }
+
+    fun expand() {
+        setCollapsed(false)
+    }
+
+    fun collapse() {
+        setCollapsed(true)
+    }
+
     fun isCollapsed(): Boolean = isCollapsed
+    
+    fun setTitle(title: String) {
+        titleLabel.text = title
+    }
 }
diff --git a/exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/TerminalSketchProvider.kt b/exts/ext-terminal/src/main/kotlin/cc/unitmesh/terminal/sketch/TerminalSketchProvider.kt
@@ -61,8 +61,16 @@ class TerminalSketchProvider : LanguageSketchProvider {
                 add(codeSketch.getComponent(), BorderLayout.CENTER)
             }
 
+            // Add result display component
+            val resultSketch = CodeHighlightSketch(project, "", CodeFence.findLanguage("bash"))
+            val resultPanel = JPanel(BorderLayout()).apply {
+                add(resultSketch.getComponent(), BorderLayout.CENTER)
+            }
+            
             val isSingleLine = content.lines().filter { it.trim().isNotEmpty() }.size <= 1
             val collapsibleCodePanel = CollapsiblePanel("Shell Code", codePanel, initiallyCollapsed = isSingleLine)
+            
+            val collapsibleResultPanel = CollapsiblePanel("Execution Results", resultPanel, initiallyCollapsed = true)
 
             val toolbarPanel = JPanel(BorderLayout()).apply {
                 add(titleLabel, BorderLayout.WEST)
@@ -82,10 +90,13 @@ class TerminalSketchProvider : LanguageSketchProvider {
                 }
 
                 codeSketch.getComponent().border = JBUI.Borders.empty()
+                resultSketch.getComponent().border = JBUI.Borders.empty()
+                
                 mainPanel = object : JPanel(VerticalLayout(JBUI.scale(0))) {
                     init {
                         add(toolbarWrapper)
                         add(collapsibleCodePanel)
+                        add(collapsibleResultPanel)
                         add(terminalWidget!!.component)
                     }
                 }
@@ -98,7 +109,26 @@ class TerminalSketchProvider : LanguageSketchProvider {
                 val executeAction = object :
                     AnAction("Execute", AutoDevBundle.message("sketch.terminal.execute"), AllIcons.Actions.Execute) {
                     override fun actionPerformed(e: AnActionEvent) {
-                        ProcessExecutor(project).executeCode(getViewText())
+                        val runResult = ProcessExecutor(project).executeCode(getViewText())
+                        ApplicationManager.getApplication().invokeLater {
+                            val resultText = if (runResult.exitCode != 0) {
+                                "${runResult.stdOutput}\n${runResult.errOutput}".trim()
+                            } else {
+                                runResult.stdOutput
+                            }
+                            
+                            resultSketch.updateViewText(resultText, true)
+                            
+                            if (collapsibleResultPanel.isCollapsed()) {
+                                collapsibleResultPanel.expand()
+                            }
+                            
+                            if (runResult.exitCode != 0) {
+                                collapsibleResultPanel.setTitle("Execution Results (Error: ${runResult.exitCode})")
+                            } else {
+                                collapsibleResultPanel.setTitle("Execution Results")
+                            }
+                        }
                     }
                 }
 
@@ -195,6 +225,7 @@ class TerminalSketchProvider : LanguageSketchProvider {
             override fun updateLanguage(language: Language?, originLanguage: String?) {}
             override fun dispose() {
                 codeSketch.dispose()
+                resultSketch.dispose()  // Make sure to dispose resultSketch
             }
         }
     }
