execute.go

package main

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

type shellConfig struct {
	path string
	args []string
}

func fileExists(path string) bool {
	// we are not using os.IsNotExist(err) to check for the error
	// because fileExists("$@#\n") would return true
	// since a new line would return a different error
	if _, err := os.Stat(path); err != nil {
		return false
	}
	return true
}

// toUnixPath converts Windows file paths to Unix-style paths for WSL.
// On non-Windows systems, it returns the path unchanged.
func toUnixPath(path string) string {
	if runtime.GOOS != "windows" {
		return path
	}

	cmds := []string{}
	for arg := range strings.FieldsSeq(path) {
		if fileExists(arg) {
			arg = strings.ReplaceAll(path, "\\", "/")
		}
		cmds = append(cmds, arg)
	}
	return strings.Join(cmds, " ")
}

// getShellConfig creates a shellConfig based on the command and interactivity.
// It uses "SHELL" or "GAS_SHELL" environment variables for the shell path.
// Supports only unix and powershell.
func getShellConfig(command string, isInteractive bool) shellConfig {
	var shellPath string
	var cmdArgs []string

	shellPath = loadEnvSetting("SHELL", "GAS_SHELL")

	switch {
	case slices.Contains([]string{"pwsh", "powershell"}, shellPath):
		if isInteractive {
			cmdArgs = []string{command}
		} else {
			cmdArgs = []string{"-NoProfile", command}
		}
	default:
		command = toUnixPath(command)

		if isInteractive {
			cmdArgs = []string{"-i", "-c", command}
		} else {
			cmdArgs = []string{"-c", command}
		}
	}

	return shellConfig{path: shellPath, args: cmdArgs}
}
func executeShellCommand(command TaskCommand, verbose bool) error {
	shellOpt := getShellConfig(command.Cmd, command.UseInteractiveShell)

	os.Chdir(command.Directory)
	cmd := exec.Command(shellOpt.path, shellOpt.args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if command.Env != "" {
		cmd.Env = os.Environ()
		cmd.Env = append(cmd.Env, command.GetEnv()...)
	}
	if verbose {
		fmt.Println(cmd)
	}

	if err := cmd.Run(); err != nil {
		return err
	}

	return nil
}

func processCommand(
	db DatabaseHistory,
	command TaskCommand,
	verbose bool,
) {
	if err := executeShellCommand(command, verbose); err != nil {
		if exitErr, ok := err.(*exec.ExitError); ok {
			command.ExitCode = exitErr.ExitCode()
			command.Status = err.Error()
		} else if strings.Contains(err.Error(), "executable file not found") {
			command.ExitCode = 127
			command.Status = "executable file not found"
		} else {
			command.ExitCode = 1 // Generic error
			command.Status = err.Error()
		}

		// delete if it's a "not found" error
		if command.ExitCode == 127 {
			db.DeleteCommand(command)
			return
		}
	} else {
		command.Status = "success"
		command.ExitCode = 0
	}

	db.UpdateCommandTimestamp(command)
	db.UpsertCommand(command)
}