feat(terminal): add completion status to LiveTerminalItem

phodal · phodal · commit 92a5b3c1dd76 · 2025-12-01T19:42:08.000+08:00
Show exit code, execution time, and output for live terminal sessions after completion. Prevent summarization or replacement of real-time terminal output. Improve fallback terminal API handling for older IDEA versions.
diff --git a/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/CodingAgentExecutor.kt b/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/CodingAgentExecutor.kt
@@ -336,6 +336,13 @@ class CodingAgentExecutor(
             return null
         }
 
+        // 对于 Live Session，不要用分析结果替换原始输出
+        // Live Terminal 已经在 Timeline 中显示实时输出了
+        val isLiveSession = executionResult.metadata["isLiveSession"] == "true"
+        if (isLiveSession) {
+            return null
+        }
+
         // 检测内容类型
         val contentType = when {
             toolName == "glob" -> "file-list"
diff --git a/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/DocumentAgentExecutor.kt b/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/DocumentAgentExecutor.kt
@@ -299,25 +299,33 @@ class DocumentAgentExecutor(
     /**
      * P1: Check for long content and delegate to AnalysisAgent for summarization
      * NOTE: Code content (from $.code.* queries) is NOT summarized to preserve actual code
+     * NOTE: Live Session output is NOT summarized to preserve real-time terminal output
      */
     private suspend fun checkForLongContent(
         toolName: String,
         output: String,
         executionResult: ToolExecutionResult
     ): ToolResult.AgentResult? {
-        
+
         if (subAgentManager == null) {
             return null
         }
-        
+
+        // 对于 Live Session，不要用分析结果替换原始输出
+        // Live Terminal 已经在 Timeline 中显示实时输出了
+        val isLiveSession = executionResult.metadata["isLiveSession"] == "true"
+        if (isLiveSession) {
+            return null
+        }
+
         val isCodeContent = output.contains("📘 class ") ||
                            output.contains("⚡ fun ") ||
                            output.contains("Found") && output.contains("entities") ||
                            output.contains("class ") && output.contains("{") ||
                            output.contains("fun ") && output.contains("(") ||
                            output.contains("def ") && output.contains(":") ||
                            output.contains("function ") && output.contains("{")
-        
+
         val contentType = when {
             isCodeContent -> "code"  // Don't summarize code!
             toolName == "docql" -> "document-content"
@@ -326,23 +334,23 @@ class DocumentAgentExecutor(
             output.contains("```") -> "code"
             else -> "text"
         }
-        
+
         // Skip summarization for code content - we want to show actual code
         if (contentType == "code") {
             logger.debug { "📊 Skipping summarization for code content (${output.length} chars)" }
             return null
         }
-        
+
         // Build metadata
         val metadata = mutableMapOf<String, String>()
         metadata["toolName"] = toolName
         metadata["executionId"] = executionResult.executionId
         metadata["success"] = executionResult.isSuccess.toString()
-        
+
         executionResult.metadata.forEach { (key, value) ->
             metadata["tool_$key"] = value
         }
-        
+
         return subAgentManager.checkAndHandleLongContent(
             content = output,
             contentType = contentType,
diff --git a/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/RendererModels.kt b/mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/RendererModels.kt
@@ -164,15 +164,31 @@ sealed class TimelineItem(
     /**
      * Live terminal session - connected to a PTY process for real-time output.
      * This is only used on platforms that support PTY (JVM with JediTerm).
+     *
+     * When the session completes, exitCode and executionTimeMs will be set.
+     * The UI can use these to show completion status without creating a separate TerminalOutputItem.
      */
     data class LiveTerminalItem(
         val sessionId: String,
         val command: String,
         val workingDirectory: String?,
         val ptyHandle: Any?, // Platform-specific: on JVM this is a PtyProcess
+        val exitCode: Int? = null, // null = still running, non-null = completed
+        val executionTimeMs: Long? = null, // null = still running
+        val output: String? = null, // Captured output when completed (optional)
         override val timestamp: Long = Platform.getCurrentTimestamp(),
         override val id: String = generateId()
-    ) : TimelineItem(timestamp, id)
+    ) : TimelineItem(timestamp, id) {
+        /**
+         * Check if the terminal session is still running
+         */
+        fun isRunning(): Boolean = exitCode == null
+
+        /**
+         * Check if the terminal session completed successfully
+         */
+        fun isSuccess(): Boolean = exitCode == 0
+    }
 
     companion object {
         /**
diff --git a/mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/renderer/JewelRenderer.kt b/mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/renderer/JewelRenderer.kt
@@ -213,23 +213,29 @@ class JewelRenderer : BaseRenderer() {
 
         // For shell commands, check if it's a live session
         val isLiveSession = metadata["isLiveSession"] == "true"
-        val liveExitCode = metadata["live_exit_code"]?.toIntOrNull()
+        val sessionId = metadata["sessionId"]
+        val liveExitCode = metadata["exit_code"]?.toIntOrNull()
 
         if (toolType == ToolType.Shell && output != null) {
             val exitCode = liveExitCode ?: (if (success) 0 else 1)
             val executionTimeMs = executionTime ?: 0L
             val command = currentToolCallInfo?.details?.removePrefix("Executing: ") ?: "unknown"
 
-            if (isLiveSession) {
-                // Add terminal output after live terminal
-                addTimelineItem(
-                    TimelineItem.TerminalOutputItem(
-                        command = command,
-                        output = fullOutput ?: output,
-                        exitCode = exitCode,
-                        executionTimeMs = executionTimeMs
-                    )
-                )
+            if (isLiveSession && sessionId != null) {
+                // Update the existing LiveTerminalItem with completion status
+                _timeline.update { items ->
+                    items.map { item ->
+                        if (item is TimelineItem.LiveTerminalItem && item.sessionId == sessionId) {
+                            item.copy(
+                                exitCode = exitCode,
+                                executionTimeMs = executionTimeMs,
+                                output = fullOutput ?: output
+                            )
+                        } else {
+                            item
+                        }
+                    }
+                }
             } else {
                 // Replace the last tool call with terminal output
                 _timeline.update { items ->
diff --git a/mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/terminal/TerminalApiCompat.kt b/mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/terminal/TerminalApiCompat.kt
@@ -96,7 +96,7 @@ object TerminalApiCompat {
     
     /**
      * Fallback approach for older IDEA versions or when new API is not available.
-     * Uses ToolWindowManager to open terminal tool window.
+     * Uses TerminalToolWindowManager to create shell widget and execute command.
      */
     private fun tryFallbackTerminalApi(
         project: Project,
@@ -105,23 +105,67 @@ object TerminalApiCompat {
         requestFocus: Boolean
     ): Boolean {
         try {
-            // Try to use ToolWindowManager to activate terminal
+            // Try to use TerminalToolWindowManager (Classic Terminal API)
+            val managerClass = Class.forName("org.jetbrains.plugins.terminal.TerminalToolWindowManager")
+            val getInstanceMethod = managerClass.getMethod("getInstance", Project::class.java)
+            val manager = getInstanceMethod.invoke(null, project)
+
+            // Create shell widget
+            val effectiveTabName = tabName ?: "AutoDev: $command"
+            val createShellWidgetMethod = managerClass.getMethod(
+                "createShellWidget",
+                String::class.java,  // workingDirectory
+                String::class.java,  // tabName
+                Boolean::class.javaPrimitiveType,  // requestFocus
+                Boolean::class.javaPrimitiveType   // deferSessionStartUntilUiShown
+            )
+
+            val widget = createShellWidgetMethod.invoke(
+                manager,
+                null,  // workingDirectory (use default)
+                effectiveTabName,
+                requestFocus,
+                false  // don't defer, start immediately
+            )
+
+            // Execute command on the widget
+            val widgetClass = widget.javaClass
+            val executeCommandMethod = widgetClass.getMethod("executeCommand", String::class.java)
+            executeCommandMethod.invoke(widget, command)
+
+            LOG.info("Successfully executed command in terminal using fallback API: $command")
+            return true
+        } catch (e: ClassNotFoundException) {
+            LOG.warn("TerminalToolWindowManager not found, trying basic activation")
+            return tryBasicTerminalActivation(project, requestFocus)
+        } catch (e: NoSuchMethodException) {
+            LOG.warn("Terminal API method not found: ${e.message}")
+            return tryBasicTerminalActivation(project, requestFocus)
+        } catch (e: Exception) {
+            LOG.warn("Fallback terminal API failed: ${e.message}", e)
+            return tryBasicTerminalActivation(project, requestFocus)
+        }
+    }
+
+    /**
+     * Last resort: just activate the terminal tool window without executing command.
+     */
+    private fun tryBasicTerminalActivation(project: Project, requestFocus: Boolean): Boolean {
+        return try {
             val toolWindowManager = com.intellij.openapi.wm.ToolWindowManager.getInstance(project)
             val terminalToolWindow = toolWindowManager.getToolWindow("Terminal")
-            
-            if (terminalToolWindow != null) {
-                if (requestFocus) {
-                    terminalToolWindow.activate(null)
-                }
-                LOG.info("Activated Terminal tool window (command not sent): $command")
+
+            if (terminalToolWindow != null && requestFocus) {
+                terminalToolWindow.activate(null)
+                LOG.info("Activated Terminal tool window (command not sent)")
                 return true
             }
-            
+
             LOG.warn("Terminal tool window not found")
-            return false
+            false
         } catch (e: Exception) {
-            LOG.warn("Fallback terminal API failed: ${e.message}", e)
-            return false
+            LOG.warn("Basic terminal activation failed: ${e.message}", e)
+            false
         }
     }
     
diff --git a/mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/agent/AgentMessageList.kt b/mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/agent/AgentMessageList.kt
@@ -222,7 +222,10 @@ fun RenderMessageItem(
                 sessionId = timelineItem.sessionId,
                 command = timelineItem.command,
                 workingDirectory = timelineItem.workingDirectory,
-                ptyHandle = timelineItem.ptyHandle
+                ptyHandle = timelineItem.ptyHandle,
+                exitCode = timelineItem.exitCode,
+                executionTimeMs = timelineItem.executionTimeMs,
+                output = timelineItem.output
             )
         }
     }
@@ -232,13 +235,20 @@ fun RenderMessageItem(
  * Platform-specific live terminal display.
  * On JVM with PTY support: Renders an interactive terminal widget
  * On other platforms: Shows a message that live terminal is not available
+ *
+ * @param exitCode Exit code when completed (null if still running)
+ * @param executionTimeMs Execution time when completed (null if still running)
+ * @param output Captured output when completed (null if still running or not captured)
  */
 @Composable
 expect fun LiveTerminalItem(
     sessionId: String,
     command: String,
     workingDirectory: String?,
-    ptyHandle: Any?
+    ptyHandle: Any?,
+    exitCode: Int? = null,
+    executionTimeMs: Long? = null,
+    output: String? = null
 )
 
 @Composable
diff --git a/mpp-ui/src/iosMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.ios.kt b/mpp-ui/src/iosMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.ios.kt
@@ -14,7 +14,10 @@ actual fun LiveTerminalItem(
     sessionId: String,
     command: String,
     workingDirectory: String?,
-    ptyHandle: Any?
+    ptyHandle: Any?,
+    exitCode: Int?,
+    executionTimeMs: Long?,
+    output: String?
 ) {
     Column(modifier = androidx.compose.ui.Modifier.padding(16.dp)) {
         Text("Terminal functionality is not available on iOS")
diff --git a/mpp-ui/src/jsMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.js.kt b/mpp-ui/src/jsMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.js.kt
@@ -19,7 +19,10 @@ actual fun LiveTerminalItem(
     sessionId: String,
     command: String,
     workingDirectory: String?,
-    ptyHandle: Any?
+    ptyHandle: Any?,
+    exitCode: Int?,
+    executionTimeMs: Long?,
+    output: String?
 ) {
     Card(
         colors =
diff --git a/mpp-ui/src/jvmMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.jvm.kt b/mpp-ui/src/jvmMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.jvm.kt
@@ -30,13 +30,17 @@ import cc.unitmesh.devins.ui.compose.theme.AutoDevColors
  * - Compact header (32-36dp) to save space in timeline
  * - Inline status indicator
  * - Clean, minimal design using AutoDevColors
+ * - Shows completion status when exitCode is provided
  */
 @Composable
 actual fun LiveTerminalItem(
     sessionId: String,
     command: String,
     workingDirectory: String?,
-    ptyHandle: Any?
+    ptyHandle: Any?,
+    exitCode: Int?,
+    executionTimeMs: Long?,
+    output: String?
 ) {
     var expanded by remember { mutableStateOf(true) } // Auto-expand live terminal
     val process =
@@ -54,7 +58,8 @@ actual fun LiveTerminalItem(
             process?.let { ProcessTtyConnector(it) }
         }
 
-    val isRunning = process?.isAlive == true
+    // Determine if running: if exitCode is provided, it's completed
+    val isRunning = exitCode == null && (process?.isAlive == true)
 
     Card(
         colors =
@@ -119,30 +124,42 @@ actual fun LiveTerminalItem(
                     modifier = Modifier.weight(1f)
                 )
 
-//                 Status badge - compact
+                // Status badge - compact, shows exit code when completed
+                val (statusText, statusColor) = when {
+                    isRunning -> "RUNNING" to AutoDevColors.Green.c400
+                    exitCode == 0 -> "✓ EXIT 0" to AutoDevColors.Green.c400
+                    exitCode != null -> "✗ EXIT $exitCode" to AutoDevColors.Red.c400
+                    else -> "DONE" to MaterialTheme.colorScheme.onSurfaceVariant
+                }
+
                 Surface(
-                    color =
-                        if (isRunning) {
-                            AutoDevColors.Green.c400.copy(alpha = 0.15f)
-                        } else {
-                            MaterialTheme.colorScheme.surfaceVariant
-                        },
+                    color = statusColor.copy(alpha = 0.15f),
                     shape = RoundedCornerShape(10.dp),
                     modifier = Modifier.height(20.dp)
                 ) {
-                    Text(
-                        text = if (isRunning) "RUNNING" else "DONE",
+                    Row(
                         modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
-                        color =
-                            if (isRunning) {
-                                AutoDevColors.Green.c400
-                            } else {
-                                MaterialTheme.colorScheme.onSurfaceVariant
-                            },
-                        style = MaterialTheme.typography.labelSmall,
-                        fontSize = 10.sp,
-                        fontWeight = FontWeight.Bold
-                    )
+                        horizontalArrangement = Arrangement.spacedBy(4.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = statusText,
+                            color = statusColor,
+                            style = MaterialTheme.typography.labelSmall,
+                            fontSize = 10.sp,
+                            fontWeight = FontWeight.Bold
+                        )
+
+                        // Show execution time when completed
+                        if (executionTimeMs != null) {
+                            Text(
+                                text = "${executionTimeMs}ms",
+                                color = statusColor.copy(alpha = 0.7f),
+                                style = MaterialTheme.typography.labelSmall,
+                                fontSize = 9.sp
+                            )
+                        }
+                    }
                 }
             }
 
diff --git a/mpp-ui/src/wasmJsMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.wasmJs.kt b/mpp-ui/src/wasmJsMain/kotlin/cc/unitmesh/devins/ui/compose/agent/LiveTerminalItem.wasmJs.kt
