executor.go

package devflow

import (
	"fmt"
	"os/exec"
	"runtime"
	"strings"
	"time"
)

// ExecCommand is a variable to allow mocking in tests
var ExecCommand = exec.Command

// RunCommand executes a shell command
// It returns the output (trimmed) and an error if the command fails
func RunCommand(name string, args ...string) (string, error) {
	// Execute
	cmd := ExecCommand(name, args...)
	outputBytes, err := cmd.CombinedOutput()
	output := strings.TrimSpace(string(outputBytes))

	if err != nil {
		cmdStr := name + " " + strings.Join(args, " ")
		return output, fmt.Errorf("command failed: %s\nError: %w\nOutput: %s", cmdStr, err, output)
	}

	return output, nil
}

// RunCommandSilent executes a command (alias for RunCommand now, as RunCommand is also silent on success)
// kept for backward compatibility if needed, or we can remove it.
// The previous implementation was identical except for logging.
func RunCommandSilent(name string, args ...string) (string, error) {
	return RunCommand(name, args...)
}

// RunShellCommand executes a shell command in a cross-platform way
// On Windows: uses cmd.exe /C
// On Unix (Linux/macOS): uses sh -c
func RunShellCommand(command string) (string, error) {
	switch runtime.GOOS {
	case "windows":
		return RunCommand("cmd.exe", "/C", command)
	default: // linux, darwin, etc.
		return RunCommand("sh", "-c", command)
	}
}

// RunShellCommandAsync starts a shell command asynchronously (non-blocking)
// Returns immediately after starting, does not wait for completion
func RunShellCommandAsync(command string) error {
	var cmd *exec.Cmd

	switch runtime.GOOS {
	case "windows":
		cmd = exec.Command("cmd.exe", "/C", command)
	default: // linux, darwin, etc.
		cmd = exec.Command("sh", "-c", command)
	}

	return cmd.Start()
}

// RunCommandWithStdin executes a command with the given string piped to stdin.
// Use this instead of passing secrets as CLI args to avoid leaking them in error messages.
func RunCommandWithStdin(input, name string, args ...string) (string, error) {
	cmd := ExecCommand(name, args...)
	cmd.Stdin = strings.NewReader(input)
	outputBytes, err := cmd.CombinedOutput()
	output := strings.TrimSpace(string(outputBytes))
	if err != nil {
		cmdStr := name + " " + strings.Join(args, " ")
		return output, fmt.Errorf("command failed: %s\nError: %w\nOutput: %s", cmdStr, err, output)
	}
	return output, nil
}

// RunCommandInDir executes a command in a specific directory
func RunCommandInDir(dir, name string, args ...string) (string, error) {
	cmd := ExecCommand(name, args...)
	cmd.Dir = dir
	outputBytes, err := cmd.CombinedOutput()
	output := strings.TrimSpace(string(outputBytes))

	if err != nil {
		cmdStr := name + " " + strings.Join(args, " ")
		return output, fmt.Errorf("command failed in %s: %s\nError: %w\nOutput: %s", dir, cmdStr, err, output)
	}

	return output, nil
}

// RunCommandWithRetryInDir executes a command in a specific directory with retries
func RunCommandWithRetryInDir(dir, name string, args []string, maxRetries int, delay time.Duration) (string, error) {
	var output string
	var err error

	for i := 0; i < maxRetries; i++ {
		output, err = RunCommandInDir(dir, name, args...)
		if err == nil {
			return output, nil
		}

		if i == maxRetries-1 {
			break
		}
		time.Sleep(delay)
	}

	return output, fmt.Errorf("command %s failed in %s after %d attempts: %w", name, dir, maxRetries, err)
}