Go command line wrapper with flexible output (stdout/file/network)

Question

Below is a command line wrapper which can parse user input command line string to Go exec.Command(). Here is why I want to write a wrapper on it:

1. exec.Command can only access command parameters 1 by 1, but I want to feed the shell command line as a whole
2. I want to run all commands in parallel(for me access multiple urls in parallel and retreive the data) - this is in exeCmd(cmdline string, output string, wg sync.WaitGroup)
3. I want to choose where the output data goes: stdout, local file or network - I defined a map which maps cmdline to output

Here is my code

package main
import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strings"
    "sync"
)
// command line parser , generate exec.Command
// cmd is same command line as running in shell(remove single quote)
func GenCmd(cmdline string) *exec.Cmd {
    fmt.Println("orgin command is ", cmdline)
    // splitting head => g++ parts => rest of the command
    parts := strings.Fields(cmdline)

    // loopArr(parts)
    head := parts[0]
    parts = parts[1:len(parts)]

    // exec cmd & collect output
    cmd := exec.Command(head, parts...)
    fmt.Printf("Generated cmdline : %s\n", cmd)
    return cmd
}
func exeCmd(cmdline string, output string, wg *sync.WaitGroup) {
    fmt.Println("Start execCmd() ")
    cmd := GenCmd(cmdline)
    // check if assigned output file
    if output != "" {
        f, err := os.Create(output)
        if err != nil {
            log.Fatal(err)
        }
        defer f.Close()
        cmd.Stdout = f // set stdout to short-response.json
        err = cmd.Run()
        if err != nil {
            log.Fatal(err)
        }
    } else {
        out, err := cmd.Output()
        if err != nil {
            fmt.Printf("%s", err)
        }
        fmt.Printf("%s", out)
    }
    wg.Done() // signal to waitgroup this goroutine complete
}
func main() {
    x := make(map[string]string)
    x["echo newline >> foo.o"] = ""
    x["echo newline >> f1.o"] = "cmd1.txt"
    cmdCnt := len(x)
    wg := new(sync.WaitGroup)
    wg.Add(cmdCnt)
    for cmd, output := range x {
        go exeCmd(cmd, output, wg) // empty string output to stdout
    }
    wg.Wait()
}

Go Playground for code above

My question is :

1. Is there a more decent way of doing this ? any exsiting go package already doing this ?
2. (better to have) Can someone help on network output part, write the output to another host