Redirect output

Author: sunfmin

.gitignore

@@ -1,3 +1,4 @@
 bin/
 *.log
 testdata/sample/sample
+.idea

pkg/debugger/client.go

@@ -1,15 +1,18 @@
 package debugger
 
 import (
+	"bufio"
 	"context"
 	"fmt"
+	"io"
 	"net"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"time"
 
 	"github.com/go-delve/delve/pkg/logflags"
+	"github.com/go-delve/delve/pkg/proc"
 	"github.com/go-delve/delve/service"
 	"github.com/go-delve/delve/service/api"
 	"github.com/go-delve/delve/service/debugger"
@@ -20,16 +23,28 @@ import (
 
 // Client encapsulates the Delve debug client functionality
 type Client struct {
-	client  *rpc2.RPCClient
-	target  string
-	pid     int
-	server  *rpccommon.ServerImpl
-	tempDir string
+	client     *rpc2.RPCClient
+	target     string
+	pid        int
+	server     *rpccommon.ServerImpl
+	tempDir    string
+	outputChan chan OutputMessage // Channel for captured output
+	stopOutput chan struct{}      // Channel to signal stopping output capture
+}
+
+// OutputMessage represents a captured output message
+type OutputMessage struct {
+	Source    string    `json:"source"` // "stdout" or "stderr"
+	Content   string    `json:"content"`
+	Timestamp time.Time `json:"timestamp"`
 }
 
 // NewClient creates a new Delve client wrapper
 func NewClient() *Client {
-	return &Client{}
+	return &Client{
+		outputChan: make(chan OutputMessage, 100), // Buffer for output messages
+		stopOutput: make(chan struct{}),
+	}
 }
 
 // LaunchProgram starts a new program with debugging enabled
@@ -68,6 +83,18 @@ func (c *Client) LaunchProgram(program string, args []string) error {
 		return fmt.Errorf("couldn't start listener: %s", err)
 	}
 
+	// Create pipes for stdout and stderr using the proc.Redirector function
+	stdoutReader, stdoutRedirect, err := proc.Redirector()
+	if err != nil {
+		return fmt.Errorf("failed to create stdout redirector: %v", err)
+	}
+
+	stderrReader, stderrRedirect, err := proc.Redirector()
+	if err != nil {
+		stdoutRedirect.File.Close()
+		return fmt.Errorf("failed to create stderr redirector: %v", err)
+	}
+
 	logger.Printf("DEBUG: Creating Delve config")
 	// Create Delve config
 	config := &service.Config{
@@ -80,9 +107,15 @@ func (c *Client) LaunchProgram(program string, args []string) error {
 			Backend:        "default",
 			CheckGoVersion: true,
 			DisableASLR:    true,
+			Stdout:         stdoutRedirect,
+			Stderr:         stderrRedirect,
 		},
 	}
 
+	// Start goroutines to capture output
+	go c.captureOutput(stdoutReader, "stdout")
+	go c.captureOutput(stderrReader, "stderr")
+
 	logger.Printf("DEBUG: Creating debug server")
 	// Create and start the debugging server
 	server := rpccommon.NewServer(config)
@@ -172,6 +205,10 @@ func (c *Client) AttachToProcess(pid int) error {
 		return fmt.Errorf("couldn't start listener: %s", err)
 	}
 
+	// Note: When attaching to an existing process, we can't easily redirect its stdout/stderr
+	// as those file descriptors are already connected. Output capture is limited for attach mode.
+	logger.Printf("DEBUG: Note: Output redirection is limited when attaching to an existing process")
+
 	logger.Printf("DEBUG: Creating Delve config for attach")
 	// Create Delve config for attaching to process
 	config := &service.Config{
@@ -310,6 +347,9 @@ func (c *Client) Close() error {
 		return nil
 	}
 
+	// Signal to stop output capturing goroutines
+	close(c.stopOutput)
+
 	// Create a context with timeout to prevent indefinite hanging
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
@@ -410,12 +450,38 @@ func (c *Client) DebugSourceFile(sourceFile string, args []string) error {
 
 	logger.Printf("DEBUG: Compiling source file %s to %s", absPath, outputBinary)
 
+	// Create pipes for build output
+	buildStdoutReader, buildStdoutWriter, err := os.Pipe()
+	if err != nil {
+		os.RemoveAll(tempDir)
+		return fmt.Errorf("failed to create stdout pipe: %v", err)
+	}
+	defer buildStdoutReader.Close()
+	defer buildStdoutWriter.Close()
+
 	// Run go build with optimizations disabled
 	buildCmd := exec.Command("go", "build", "-gcflags", "all=-N -l", "-o", outputBinary, absPath)
-	buildOutput, err := buildCmd.CombinedOutput()
+	buildCmd.Stdout = buildStdoutWriter
+	buildCmd.Stderr = buildStdoutWriter
+	
+	err = buildCmd.Start()
 	if err != nil {
-		os.RemoveAll(tempDir) // Clean up temp directory on error
-		return fmt.Errorf("failed to compile source file: %v\nOutput: %s", err, buildOutput)
+		os.RemoveAll(tempDir)
+		return fmt.Errorf("failed to start compilation: %v", err)
+	}
+
+	// Capture build output
+	go func() {
+		scanner := bufio.NewScanner(buildStdoutReader)
+		for scanner.Scan() {
+			logger.Printf("Build output: %s", scanner.Text())
+		}
+	}()
+	
+	err = buildCmd.Wait()
+	if err != nil {
+		os.RemoveAll(tempDir)
+		return fmt.Errorf("failed to compile source file: %v", err)
 	}
 
 	// Launch the compiled binary with the debugger
@@ -975,3 +1041,47 @@ func (c *Client) GetExecutionPosition() (*ExecutionPosition, error) {
 
 	return result, nil
 }
+
+// captureOutput reads from a reader and sends the output to the output channel
+func (c *Client) captureOutput(reader io.ReadCloser, source string) {
+	defer reader.Close()
+	
+	scanner := bufio.NewScanner(reader)
+	for scanner.Scan() {
+		select {
+		case <-c.stopOutput:
+			return
+		case c.outputChan <- OutputMessage{
+			Source:    source,
+			Content:   scanner.Text(),
+			Timestamp: time.Now(),
+		}:
+		}
+	}
+}
+
+// GetCapturedOutput returns the next captured output message
+// Returns nil when there are no more messages
+func (c *Client) GetCapturedOutput() *OutputMessage {
+	select {
+	case msg := <-c.outputChan:
+		return &msg
+	default:
+		return nil
+	}
+}
+
+// GetAllCapturedOutput returns all currently available captured output messages
+func (c *Client) GetAllCapturedOutput() []OutputMessage {
+	var messages []OutputMessage
+	
+	// Collect all available messages without blocking
+	for {
+		select {
+		case msg := <-c.outputChan:
+			messages = append(messages, msg)
+		default:
+			return messages
+		}
+	}
+}

pkg/mcp/server.go

@@ -108,6 +108,7 @@ func (s *MCPDebugServer) registerTools() {
 	s.addExamineVariableTool()
 	s.addListScopeVariablesTool()
 	s.addGetExecutionPositionTool()
+	s.addGetDebuggerOutputTool()
 }
 
 // addPingTool adds a simple ping tool for health checks
@@ -294,6 +295,15 @@ func (s *MCPDebugServer) addGetExecutionPositionTool() {
 	s.server.AddTool(positionTool, s.GetExecutionPosition)
 }
 
+// addGetDebuggerOutputTool registers the get_debugger_output tool
+func (s *MCPDebugServer) addGetDebuggerOutputTool() {
+	outputTool := mcp.NewTool("get_debugger_output",
+		mcp.WithDescription("Get captured stdout and stderr from the debugged program"),
+	)
+
+	s.server.AddTool(outputTool, s.GetDebuggerOutput)
+}
+
 // newErrorResult creates a tool result that represents an error
 func newErrorResult(format string, args ...interface{}) *mcp.CallToolResult {
 	result := mcp.NewToolResultText(fmt.Sprintf("Error: "+format, args...))
@@ -705,4 +715,29 @@ func (s *MCPDebugServer) GetExecutionPosition(ctx context.Context, request mcp.C
 	}
 
 	return mcp.NewToolResultText(string(jsonBytes)), nil
+}
+
+// GetDebuggerOutput retrieves any captured stdout/stderr from the debugged program
+func (s *MCPDebugServer) GetDebuggerOutput(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	if s.debugClient == nil || !s.debugClient.IsConnected() {
+		return newErrorResult("No active debug session"), nil
+	}
+
+	// Get all captured output
+	messages := s.debugClient.GetAllCapturedOutput()
+	
+	// Format the messages into a response
+	var response struct {
+		Messages []debugger.OutputMessage `json:"messages"`
+	}
+	response.Messages = messages
+	
+	// Convert to JSON
+	outputJSON, err := json.Marshal(response)
+	if err != nil {
+		return newErrorResult("Failed to marshal output messages: %v", err), nil
+	}
+	
+	// Return the output
+	return mcp.NewToolResultText(string(outputJSON)), nil
 } 

pkg/mcp/server_test.go

@@ -615,6 +615,14 @@ func TestDebugWorkflow(t *testing.T) {
 	// Allow time for program to complete
 	time.Sleep(300 * time.Millisecond)
 
+	// Check for captured output
+	outputRequest := mcp.CallToolRequest{}
+	outputResult, err := server.GetDebuggerOutput(ctx, outputRequest)
+	if err == nil && outputResult != nil {
+		outputText := getTextContent(outputResult)
+		t.Logf("Captured program output: %s", outputText)
+	}
+
 	// Clean up by closing the debug session
 	closeRequest := mcp.CallToolRequest{}
 	closeResult, err := server.Close(ctx, closeRequest)