fix(local): replace bufio.Scanner with bufio.Reader and implement Execute

- Replace bufio.Scanner with bufio.Reader in streamStdout to handle long lines
- Implement Local.Execute using exec.CommandContext with /bin/sh -c
- Capture stdout/stderr separately, return stderr in error on non-zero exit
- Add unit tests for Execute method

Author: zhuangjie1125

adk/backend/agentkit/code_template.go

@@ -246,7 +246,11 @@ try:
 
     # Check for stderr
     if result.stderr:
-        print(f"Error executing command: {{result.stderr}}", file=sys.stderr)
+        output_parts = []
+        if result.stdout:
+            output_parts.append(f"[stdout]:\n{{result.stdout.rstrip()}}")
+        output_parts.append(f"[stderr]:\n{{result.stderr.rstrip()}}")
+        print('\n'.join(output_parts), end='')
         sys.exit(result.returncode if result.returncode != 0 else 1)
     
     # Print stdout

adk/backend/local/local.go

@@ -396,6 +396,46 @@ func (s *Local) ExecuteStreaming(ctx context.Context, input *filesystem.ExecuteR
 	return sr, nil
 }
 
+func (s *Local) Execute(ctx context.Context, input *filesystem.ExecuteRequest) (result *filesystem.ExecuteResponse, err error) {
+	if input.Command == "" {
+		return nil, fmt.Errorf("command is required")
+	}
+
+	if err := s.validateCommand(input.Command); err != nil {
+		return nil, err
+	}
+
+	cmd := exec.CommandContext(ctx, "/bin/sh", "-c", input.Command)
+
+	var stdoutBuf, stderrBuf strings.Builder
+	cmd.Stdout = &stdoutBuf
+	cmd.Stderr = &stderrBuf
+
+	exitCode := 0
+	if err := cmd.Run(); err != nil {
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) {
+			exitCode = exitError.ExitCode()
+			stdoutStr := stdoutBuf.String()
+			stderrStr := stderrBuf.String()
+			parts := []string{fmt.Sprintf("command exited with non-zero code %d", exitCode)}
+			if stdoutStr != "" {
+				parts = append(parts, "stdout: "+stdoutStr)
+			}
+			if stderrStr != "" {
+				parts = append(parts, "stderr: "+stderrStr)
+			}
+			return nil, errors.New(strings.Join(parts, "\n"))
+		}
+		return nil, fmt.Errorf("failed to execute command: %w", err)
+	}
+
+	return &filesystem.ExecuteResponse{
+		Output:   stdoutBuf.String(),
+		ExitCode: &exitCode,
+	}, nil
+}
+
 // initStreamingCmd creates command with stdout and stderr pipes.
 func (s *Local) initStreamingCmd(ctx context.Context, command string) (*exec.Cmd, io.ReadCloser, io.ReadCloser, error) {
 	cmd := exec.CommandContext(ctx, "/bin/sh", "-c", command)
@@ -512,23 +552,27 @@ func (s *Local) readStderrAsync(stderr io.Reader) (*[]byte, <-chan error) {
 
 // streamStdout streams stdout line by line to the writer.
 func (s *Local) streamStdout(ctx context.Context, cmd *exec.Cmd, stdout io.Reader, w *schema.StreamWriter[*filesystem.ExecuteResponse]) (bool, error) {
-	scanner := bufio.NewScanner(stdout)
+	reader := bufio.NewReader(stdout)
 	hasOutput := false
 
-	for scanner.Scan() {
-		hasOutput = true
-		line := scanner.Text() + "\n"
-		select {
-		case <-ctx.Done():
-			_ = cmd.Process.Kill()
-			return hasOutput, ctx.Err()
-		default:
-			w.Send(&filesystem.ExecuteResponse{Output: line}, nil)
+	for {
+		line, err := reader.ReadString('\n')
+		if line != "" {
+			hasOutput = true
+			select {
+			case <-ctx.Done():
+				_ = cmd.Process.Kill()
+				return hasOutput, ctx.Err()
+			default:
+				w.Send(&filesystem.ExecuteResponse{Output: line}, nil)
+			}
+		}
+		if err != nil {
+			if err != io.EOF {
+				return hasOutput, fmt.Errorf("error reading stdout: %w", err)
+			}
+			break
 		}
-	}
-
-	if err := scanner.Err(); err != nil {
-		return hasOutput, fmt.Errorf("error reading stdout: %w", err)
 	}
 
 	return hasOutput, nil

adk/backend/local/local_test.go

@@ -777,3 +777,65 @@ func TestExecuteStreaming(t *testing.T) {
 		assert.Less(t, elapsed, 2*time.Second, "background command should return immediately without waiting")
 	})
 }
+
+func TestExecute(t *testing.T) {
+	ctx := context.Background()
+	s, err := NewBackend(ctx, &Config{})
+	assert.NoError(t, err)
+
+	t.Run("simple echo", func(t *testing.T) {
+		resp, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: "echo hello"})
+		assert.NoError(t, err)
+		assert.Equal(t, "hello\n", resp.Output)
+		assert.NotNil(t, resp.ExitCode)
+		assert.Equal(t, 0, *resp.ExitCode)
+	})
+
+	t.Run("multi-line output", func(t *testing.T) {
+		resp, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: "echo line1 && echo line2 && echo line3"})
+		assert.NoError(t, err)
+		assert.Equal(t, "line1\nline2\nline3\n", resp.Output)
+		assert.Equal(t, 0, *resp.ExitCode)
+	})
+
+	t.Run("empty command", func(t *testing.T) {
+		_, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: ""})
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "command is required")
+	})
+
+	t.Run("non-zero exit code", func(t *testing.T) {
+		_, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: "exit 1"})
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "non-zero code")
+	})
+
+	t.Run("non-zero exit code with stderr", func(t *testing.T) {
+		_, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: "echo fail >&2 && exit 2"})
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "non-zero code 2")
+		assert.Contains(t, err.Error(), "fail")
+	})
+
+	t.Run("command not found", func(t *testing.T) {
+		_, err := s.Execute(ctx, &filesystem.ExecuteRequest{Command: "nonexistent_command_xyz"})
+		assert.Error(t, err)
+	})
+
+	t.Run("context cancellation", func(t *testing.T) {
+		cancelCtx, cancel := context.WithCancel(ctx)
+		cancel()
+		_, err := s.Execute(cancelCtx, &filesystem.ExecuteRequest{Command: "sleep 10"})
+		assert.Error(t, err)
+	})
+
+	t.Run("context cancellation during execution", func(t *testing.T) {
+		cancelCtx, cancel := context.WithCancel(ctx)
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			cancel()
+		}()
+		_, err := s.Execute(cancelCtx, &filesystem.ExecuteRequest{Command: "sleep 10"})
+		assert.Error(t, err)
+	})
+}