remove all the ctrl+c logic

Author: xinyi-gong

com.microsoft.copilot.eclipse.terminal.api/src/com/microsoft/copilot/eclipse/terminal/api/TerminalCommandProcessor.java

@@ -104,49 +104,37 @@ public static String prepareOutputForModel(String output) {
    * Attempts to complete a command using shell integration markers.
    *
    * @param output terminal output buffer
-   * @param activeCommand command currently being executed
-   * @param skipCompletion whether to skip the next completed command region
    * @return the completion check result
    */
-  public static CompletionCheckResult tryCompleteWithMarker(StringBuilder output, String activeCommand,
-      boolean skipCompletion) {
-    MarkerRange commandFinishMarkerRange = findCommandFinishMarker(output);
+  public static CompletionCheckResult tryCompleteWithMarker(StringBuilder output) {
+    MarkerRange commandFinishMarkerRange = findMarker(output, COMMAND_FINISH_MARKER_PATTERN, 0);
     if (commandFinishMarkerRange == null) {
       // Startup or idle prompts can arrive before a command runs. Keep the visible prompt text, but remove marker
       // bytes so later command output cleanup does not have to handle stale prompt boundaries.
       removePromptMarkers(output);
       return CompletionCheckResult.incomplete();
     }
 
-    // The command-finished marker is emitted before the next prompt. Wait for prompt end so the returned output keeps
-    // the prompt line, which gives the language model the terminal's current working directory.
+    // A complete marker command is the command finish marker followed by the next prompt end. Waiting for B keeps the
+    // prompt line in the returned output, which gives the language model the terminal's current working directory.
     MarkerRange promptEndMarkerRange = findMarker(output, PROMPT_END_MARKER_PATTERN, commandFinishMarkerRange.endIndex);
     if (promptEndMarkerRange == null) {
       return CompletionCheckResult.incomplete();
     }
 
-    // Keep command output plus the next prompt, but remove the command-finished marker itself, including exit code.
+    // Keep terminal output plus the next prompt, but exclude command finish markers.
     String completedOutput = output.substring(0, commandFinishMarkerRange.startIndex)
         + output.substring(commandFinishMarkerRange.endIndex, promptEndMarkerRange.endIndex);
-    if (shouldSkipCompletion(completedOutput, activeCommand, skipCompletion)) {
-      // This region belongs to a command that was interrupted by Ctrl+C. Drop it so it cannot complete the next
-      // foreground command that may already be listening on the same terminal output buffer.
-      output.delete(0, promptEndMarkerRange.endIndex);
-      return CompletionCheckResult.skipped();
-    }
-    return CompletionCheckResult.completed(cleanCommandOutput(completedOutput, activeCommand));
+    return CompletionCheckResult.completed(cleanCommandOutput(completedOutput));
   }
 
   /**
    * Attempts to complete a command by detecting a shell prompt.
    *
    * @param output terminal output buffer
-   * @param activeCommand command currently being executed
-   * @param skipCompletion whether to skip the next completed command region
    * @return the completion check result
    */
-  public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output, String activeCommand,
-      boolean skipCompletion) {
+  public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output) {
     String terminalOutput = output.toString().trim();
     int lastNewLineIndex = terminalOutput.lastIndexOf('\n');
     if (lastNewLineIndex <= 0) {
@@ -164,11 +152,6 @@ public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output,
       return CompletionCheckResult.incomplete();
     }
 
-    if (shouldSkipCompletion(terminalOutput, activeCommand, skipCompletion)) {
-      output.setLength(0);
-      return CompletionCheckResult.skipped();
-    }
-
     String contentWithoutLastPrompt = terminalOutput.substring(0, lastNewLineIndex);
     int promptStartIndex = contentWithoutLastPrompt.indexOf(lastLine);
     if (promptStartIndex == -1) {
@@ -183,17 +166,6 @@ public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output,
     return CompletionCheckResult.completed(contentWithoutLastPrompt.substring(promptStartIndex).trim());
   }
 
-  private static boolean shouldSkipCompletion(String completedRegion, String activeCommand, boolean skipCompletion) {
-    if (!skipCompletion) {
-      return false;
-    }
-    String normalizedCommand = normalizeLineEndings(activeCommand == null ? "" : activeCommand).trim();
-    if (normalizedCommand.isBlank()) {
-      return true;
-    }
-    return !normalizeLineEndings(completedRegion).contains(normalizedCommand);
-  }
-
   private static String removeBracketedPasteMarkers(String output) {
     return output.replace(BRACKETED_PASTE_START, "").replace(BRACKETED_PASTE_END, "");
   }
@@ -217,10 +189,6 @@ private static String removeTrailingLineEndings(String value) {
     return value.substring(0, endIndex);
   }
 
-  private static MarkerRange findCommandFinishMarker(StringBuilder output) {
-    return findMarker(output, COMMAND_FINISH_MARKER_PATTERN, 0);
-  }
-
   private static MarkerRange findMarker(StringBuilder output, Pattern markerPattern, int startIndex) {
     Matcher matcher = markerPattern.matcher(output);
     if (!matcher.find(startIndex)) {
@@ -248,18 +216,10 @@ private static Pattern buildMarkerPattern(String markerKind, boolean includeExit
         + exitCodePattern + "(?:\u0007|\u001B\\\\)?");
   }
 
-  private static String cleanCommandOutput(String output, String activeCommand) {
+  private static String cleanCommandOutput(String output) {
     String normalizedOutput = normalizeLineEndings(output);
     normalizedOutput = removeShellIntegrationMarkers(normalizedOutput);
     normalizedOutput = removeBracketedPasteMarkers(normalizedOutput);
-    String normalizedCommand = normalizeLineEndings(activeCommand == null ? "" : activeCommand).trim();
-    if (normalizedCommand.isBlank()) {
-      return normalizedOutput.trim();
-    }
-    int commandIndex = normalizedOutput.lastIndexOf(normalizedCommand);
-    if (commandIndex >= 0) {
-      normalizedOutput = normalizedOutput.substring(commandIndex + normalizedCommand.length());
-    }
     return normalizedOutput.trim();
   }
 
@@ -294,10 +254,6 @@ private static CompletionCheckResult incomplete() {
       return new CompletionCheckResult(CompletionCheckState.INCOMPLETE, "");
     }
 
-    private static CompletionCheckResult skipped() {
-      return new CompletionCheckResult(CompletionCheckState.SKIPPED, "");
-    }
-
     private static CompletionCheckResult completed(String output) {
       return new CompletionCheckResult(CompletionCheckState.COMPLETED, output);
     }
@@ -308,7 +264,6 @@ private static CompletionCheckResult completed(String output) {
    */
   public enum CompletionCheckState {
     INCOMPLETE,
-    SKIPPED,
     COMPLETED
   }
-}
+}

com.microsoft.copilot.eclipse.ui.terminal.tm/src/com/microsoft/copilot/eclipse/ui/terminal/tm/RunInTerminalTool.java

@@ -51,7 +51,6 @@ public class RunInTerminalTool implements IRunInTerminalTool {
   private static final Map<String, StringBuilder> backgroundCommandOutputs = new HashMap<>();
   private static final String BACKGROUND_TERMINAL_PREFIX = "Copilot-";
   private static final String POWERSHELL_SCRIPT_ENV = "COPILOT_POWERSHELL_INTEGRATION_SCRIPT";
-  private static final char INTERRUPT_CHARACTER = '\u0003';
   private static final String COMMAND_CANCELLED_MESSAGE = "Terminal command cancelled.";
   private static final String COMMAND_INTERRUPTED_MESSAGE = "Terminal command interrupted by a new command.";
 
@@ -68,7 +67,6 @@ public class RunInTerminalTool implements IRunInTerminalTool {
   // Output and command state
   private StringBuilder sb;
   private volatile ForegroundCommand foregroundCommand;
-  private volatile boolean skipNextCompletionAfterInterrupt;
 
   /**
    * Constructor for RunInTerminalTool.
@@ -84,14 +82,12 @@ public CompletableFuture<String> executeCommand(String command, boolean isBackgr
     }
 
     if (!isBackground) {
-      // A new foreground command immediately installs a new future after Ctrl+C, so the interrupted command's
-      // next prompt-completion marker must be skipped if it arrives after the new command starts listening.
-      interruptCurrentCommand(COMMAND_INTERRUPTED_MESSAGE, true);
+      closeRunningForegroundTerminal(COMMAND_INTERRUPTED_MESSAGE);
     }
 
     CompletableFuture<String> commandFuture = new CompletableFuture<>();
     ForegroundCommand commandState = isBackground ? null
-        : new ForegroundCommand(commandFuture, command, hasShellIntegrationMarker());
+        : new ForegroundCommand(commandFuture, hasShellIntegrationMarker());
 
     if (commandState != null) {
       foregroundCommand = commandState;
@@ -217,56 +213,48 @@ public StringBuilder getBackgroundCommandOutput(String executionId) {
 
   @Override
   public void cancelCurrentCommand() {
-    // User cancel completes the current future without starting a replacement command. Do not reserve a skip here,
-    // otherwise a later command could incorrectly skip its own completion if the interrupted prompt was already idle.
-    interruptCurrentCommand(COMMAND_CANCELLED_MESSAGE, false);
+    closeRunningForegroundTerminal(COMMAND_CANCELLED_MESSAGE);
   }
 
-  private void interruptCurrentCommand(String completionMessage, boolean skipInterruptedCompletion) {
-    ITerminalViewControl terminalViewControl = null;
+  private void closeRunningForegroundTerminal(String completionMessage) {
+    ForegroundCommand commandState = foregroundCommand;
+    if (commandState != null && !commandState.future().isDone()) {
+      closeCurrentForegroundTerminal(completionMessage);
+    }
+  }
+
+  private void closeCurrentForegroundTerminal(String completionMessage) {
     ForegroundCommand commandState = null;
+    CTabItem tabItem = null;
     synchronized (lock) {
-      if (!hasRunningForegroundCommand()) {
-        if (!skipInterruptedCompletion) {
-          skipNextCompletionAfterInterrupt = false;
-        }
-        return;
-      }
       commandState = foregroundCommand;
       foregroundCommand = null;
-      skipNextCompletionAfterInterrupt = skipInterruptedCompletion;
-      terminalViewControl = persistentTerminalViewControl;
+      persistentTerminalViewControl = null;
+      tabItem = copilotTabItem;
+      copilotTabItem = null;
+      sb.setLength(0);
     }
 
-    if (terminalViewControl != null) {
-      sendInterrupt(terminalViewControl);
+    if (tabItem != null) {
+      final CTabItem tabItemToDispose = tabItem;
+      // Keep this synchronous so a new foreground command cannot open before the old terminal tab is disposed.
+      Display.getDefault().syncExec(() -> {
+        if (!tabItemToDispose.isDisposed()) {
+          tabItemToDispose.dispose();
+        }
+      });
     }
     if (commandState != null && !commandState.future().isDone()) {
       commandState.future().complete(completionMessage);
     }
   }
 
-  private boolean hasRunningForegroundCommand() {
-    ForegroundCommand commandState = foregroundCommand;
-    return commandState != null && !commandState.future().isDone();
-  }
-
   private void clearForegroundCommand(ForegroundCommand commandState) {
     if (commandState != null && foregroundCommand == commandState) {
       foregroundCommand = null;
     }
   }
 
-  private void sendInterrupt(ITerminalViewControl terminalViewControl) {
-    Display display = terminalViewControl.getControl().getDisplay();
-    // Ctrl+C must be delivered before the next foreground command is pasted into the reused terminal.
-    display.syncExec(() -> {
-      if (!terminalViewControl.isDisposed()) {
-        terminalViewControl.sendKey(INTERRUPT_CHARACTER);
-      }
-    });
-  }
-
   private void sendCommand(ITerminalViewControl terminalViewControl, String command) {
     terminalViewControl.pasteString(command);
   }
@@ -363,16 +351,10 @@ private ITerminalServiceOutputStreamMonitorListener buildOutputStreamMonitorList
       // Detect completion based on platform strategy
       ForegroundCommand commandState = foregroundCommand;
       if (!isBackground && commandState != null && !commandState.future().isDone()) {
-        CompletionCheckResult completionResult;
-        do {
-          completionResult = commandState.useMarker()
-              ? TerminalCommandProcessor.tryCompleteWithMarker(output, commandState.command(),
-                  skipNextCompletionAfterInterrupt)
-              : TerminalCommandProcessor.tryCompleteWithPrompt(output, commandState.command(),
-                  skipNextCompletionAfterInterrupt);
-          handleCompletionResult(commandState, completionResult);
-        } while (completionResult.state() == CompletionCheckState.SKIPPED
-            && foregroundCommand == commandState && !commandState.future().isDone());
+        CompletionCheckResult completionResult = commandState.useMarker()
+            ? TerminalCommandProcessor.tryCompleteWithMarker(output)
+            : TerminalCommandProcessor.tryCompleteWithPrompt(output);
+        handleCompletionResult(commandState, completionResult);
       }
     };
   }
@@ -381,10 +363,6 @@ private void handleCompletionResult(ForegroundCommand commandState, CompletionCh
     if (completionResult.state() == CompletionCheckState.INCOMPLETE) {
       return;
     }
-    if (completionResult.state() == CompletionCheckState.SKIPPED) {
-      skipNextCompletionAfterInterrupt = false;
-      return;
-    }
     if (foregroundCommand == commandState) {
       foregroundCommand = null;
     }
@@ -436,7 +414,7 @@ private String buildBackgroundTerminalTitle(String executionId) {
     return BACKGROUND_TERMINAL_PREFIX + executionId;
   }
 
-  private record ForegroundCommand(CompletableFuture<String> future, String command, boolean useMarker) {
+  private record ForegroundCommand(CompletableFuture<String> future, boolean useMarker) {
   }
 
   /**