Misc refinements

Signed-off-by: James Ostrander <jostrand@redhat.com>

Author: jlost

README.md

@@ -264,6 +264,30 @@ When a launch configuration has a `preLaunchTask` that uses input variables (`${
 
 This is because background tasks and task dependencies require VS Code's native task orchestration.
 
+### Go Debug Output Capture
+
+The Go debug adapter (Delve) writes test output directly to stdout/stderr rather than routing it through the Debug Adapter Protocol. When Ignition MCP overrides `console: "integratedTerminal"` to `"internalConsole"` for output capture, this output is lost because there's no terminal to receive it.
+
+**Symptoms**: Debug session runs successfully but no output appears in the debug console or in `get_debug_output` results, even though running the same configuration manually shows output.
+
+**Workaround**: Disable the console override for Go launch configurations:
+
+```json
+{
+  "name": "Run Tests",
+  "type": "go",
+  "request": "launch",
+  "mode": "test",
+  "program": "${workspaceFolder}/...",
+  "console": "integratedTerminal",
+  "mcp": {
+    "preserveConsole": true
+  }
+}
+```
+
+With `preserveConsole: true`, the terminal is created and output is visible, but Ignition MCP cannot capture it programmatically.
+
 ## 📄 License
 
 MIT

src/launch/launchManager.ts

@@ -229,19 +229,26 @@ export class LaunchManager implements vscode.Disposable {
 
   private handleDebugEvent(sessionId: string, event: string | undefined, body: Record<string, unknown> | undefined) {
     const info = this.sessions.get(sessionId);
-    if (!body) return;
     const previousState = info?.state;
     switch (event) {
       case 'initialized':
         if (info) {
           info.state = 'running';
         }
         break;
+      case 'exited':
+      case 'terminated':
+        if (info) {
+          info.state = 'terminated';
+        }
+        break;
       case 'output':
-        this.captureOutput(sessionId, body);
+        if (body) {
+          this.captureOutput(sessionId, body);
+        }
         break;
       case 'stopped':
-        if (info) {
+        if (info && body) {
           info.state = 'paused';
           info.stopReason = body.reason as string | undefined;
           info.stoppedThreadId = body.threadId as number | undefined;
@@ -260,12 +267,6 @@ export class LaunchManager implements vscode.Disposable {
           info.stoppedThreadId = undefined;
         }
         break;
-      case 'exited':
-      case 'terminated':
-        if (info) {
-          info.state = 'terminated';
-        }
-        break;
     }
     if (info && previousState !== info.state) {
       this.notifyStateChange(sessionId, info.state, info);

src/server/mcpServer.ts

@@ -413,6 +413,7 @@ export class MCPServer {
   private registerTaskTool(task: TaskInfo, allInputs: InputDefinition[]) {
     const toolName = this.sanitizeToolName(task.name, 'task_');
     const isBackground = task.isBackground;
+    const isInteractive = task.mcpOptions?.interactive ?? false;
     const description = this.buildTaskDescription(task);
     const hasInputs = allInputs.length > 0;
     const inputSchema = hasInputs ? this.buildInputSchema(allInputs) : {};
@@ -433,7 +434,9 @@ export class MCPServer {
             userWillBePrompted = true;
           }
         }
-        if (isBackground) {
+        // Background tasks and interactive tasks both return immediately
+        // Interactive tasks can't capture output and may run for arbitrary durations
+        if (isBackground || isInteractive) {
           const result = await this.taskManager.runTask(task.name, inputValues, task.mcpOptions);
           if (!result.success) {
             return {
@@ -446,13 +449,19 @@ export class MCPServer {
           }
           const response: Record<string, unknown> = {
             status: 'started',
-            message: `Background task "${task.name}" started. Use await_task to wait for completion.`,
+            message: isInteractive 
+              ? `Interactive task "${task.name}" started. Use await_task to wait for completion.`
+              : `Background task "${task.name}" started. Use await_task to wait for completion.`,
             executionId: result.executionId,
-            isBackground: true
+            isBackground: isBackground,
+            isInteractive: isInteractive
           };
           if (userWillBePrompted) {
             response.note = 'User will be prompted for missing input values in VS Code.';
           }
+          if (isInteractive) {
+            response.outputNote = 'Output not captured in interactive mode.';
+          }
           return {
             content: [{
               type: 'text' as const,
@@ -617,6 +626,10 @@ export class MCPServer {
           response.consoleOverridden = true;
           response.consoleNote = 'Console mode was changed to internalConsole for output capture.';
         }
+        if (config.mcpOptions?.preserveConsole) {
+          response.outputNotCaptured = true;
+          response.outputNote = 'Output runs in terminal for human visibility. get_debug_output will not return results.';
+        }
         if (userWillBePrompted) {
           response.userPrompted = true;
           response.note = 'User will be prompted for missing input values in VS Code. Use get_debug_status to check session state.';
@@ -646,6 +659,9 @@ export class MCPServer {
       parts.push(`Runs "${config.preLaunchTask}" task first.`);
     }
     parts.push('(starts and returns immediately)');
+    if (config.mcpOptions?.preserveConsole) {
+      parts.push('[OUTPUT NOT CAPTURED: runs in terminal for human visibility]');
+    }
     return parts.join(' ');
   }
 

src/tasks/taskManager.ts

@@ -470,8 +470,9 @@ export class TaskManager implements vscode.Disposable {
     inputValues?: Record<string, string>
   ): Promise<TaskRunResult> {
     try {
-      let taskToRun = task;
+      let taskToRun: vscode.Task;
       if (inputValues && Object.keys(inputValues).length > 0) {
+        // Need to substitute input values - create a modified task
         const rawCommand = this.getRawCommand(task);
         let resolvedCommand = rawCommand;
         for (const [inputId, value] of Object.entries(inputValues)) {
@@ -500,20 +501,10 @@ export class TaskManager implements vscode.Disposable {
           focus: true
         };
       } else {
-        const shellExec = task.execution;
-        taskToRun = new vscode.Task(
-          task.definition,
-          task.scope || vscode.TaskScope.Workspace,
-          task.name,
-          task.source,
-          shellExec,
-          task.problemMatchers
-        );
-        taskToRun.presentationOptions = {
-          ...task.presentationOptions,
-          reveal: vscode.TaskRevealKind.Always,
-          focus: true
-        };
+        // No input substitution needed - use the original task directly
+        // This preserves VS Code's internal task definition and avoids
+        // issues where recreating the task loses the command
+        taskToRun = task;
       }
       this.interactiveExecutionIds.add(executionId);
       const execution = await vscode.tasks.executeTask(taskToRun);
@@ -739,9 +730,11 @@ export class TaskManager implements vscode.Disposable {
     const execId = this.findExecutionId(e.execution);
     if (execId) {
       this.log(`Found execution ID ${execId} for ended task "${taskName}"`);
+      // Clean up tracking structures (only here, not in onTaskProcessEnded)
       this.activeExecutions.delete(execId);
       this.executionToId.delete(e.execution);
       this.interactiveExecutionIds.delete(execId);
+      // Update status if not already set by onTaskProcessEnded
       const info = this.executions.get(execId);
       if (info && info.status === 'running') {
         info.status = 'completed';
@@ -759,6 +752,7 @@ export class TaskManager implements vscode.Disposable {
     const execId = this.findExecutionId(e.execution);
     if (execId) {
       this.log(`Found execution ID ${execId} for process-ended task "${taskName}"`);
+      // Only update status/exitCode here - cleanup happens in onTaskEnded
       const info = this.executions.get(execId);
       if (info) {
         info.exitCode = e.exitCode;
@@ -768,9 +762,7 @@ export class TaskManager implements vscode.Disposable {
           this.log(`Updated status to '${info.status}' with exit code ${e.exitCode} for execution ${execId}`);
         }
       }
-      this.activeExecutions.delete(execId);
-      this.executionToId.delete(e.execution);
-      this.interactiveExecutionIds.delete(execId);
+      // Don't clean up here - let onTaskEnded do it to avoid race condition
     } else {
       this.log(`No execution ID found for process-ended task "${taskName}" (may be external task)`);
     }