How to correctly implement a goroutine in terminal application

I'm trying to create a HTTP request interface in the terminal where you can pass some data (url, response body, etc) and then I make the request and display the data somewhere.
I'm trying to do the request in a goroutine, and display the results that the channel gives me. When I'm doing quick requests, this is impossible to note, but I created a simple Node endpoint to test a computationally heavy endpoint:

    app.use(express.json())
    
    app.get("/", (req, res) => {     
         new Promise(resolve => {
             setTimeout(() => resolve(), 3000)
         }).then(() => res.status(200).json({message: "OK"}))
        .catch(err => res.status(500).json({error: err.message}))
    })
   
    app.listen(4000, () => console.log("Server up"))

When I call this endpoint, the whole ui freezes and only after the request is complete I can continue to use the GUI. For example, I tried to include a loading box at the GUI while the requests were being made, but the freeze happened, and the loading got displayed after the request completed.

Here's the code for the httpRequest function

func httpRequest(url, method string, body []byte, results chan Result) {
	client := &http.Client{}
	req, err := http.NewRequest(method, url, bytes.NewBuffer(body))
	req.Header.Add("content-type", "application/json")
	if err != nil {
		results <- Result{err: err}
	}

	res, err := client.Do(req)
	if err != nil {
		results <- Result{err: err}
	}

	defer res.Body.Close()

	r := Result{
		method: res.Request.Method,
		url:    res.Request.URL.String(),
		path:   res.Request.URL.Path,
		proto:  res.Proto,
		status: res.Status,
		header: res.Header,
	}

	b, err := io.ReadAll(res.Body)
	if err != nil {
		results <- Result{err: err}
	}

	r.body = string(b)
	results <- r
} 

It is going to be called on the processRequest function:

func processRequest(g *ui.Gui, v *ui.View) error {
	method_view, err := g.View("method")
	if err != nil {
	    return err
	 }
	 method_view.Clear()
	 fmt.Fprintln(method_view, "loading...")

	
     // GET ALL REQUEST DATA HERE...


	out, err := g.View("res-output")
	if err != nil {
		return err
	}

	r := make(chan Result, 1)
	start := time.Now()

	switch active_method {
	case 0:
		go httpRequest(api_url, "GET", nil, r)
	case 1:
		go httpRequest(api_url, "POST", request_body_data, r)
	case 2:
		go httpRequest(api_url, "DELETE", request_body_data, r)
	case 3:
		go httpRequest(api_url, "PUT", request_body_data, r)
	}

	result := <-r
	if result.err != nil {
		fmt.Fprintf(out, "Error: %s\n", result.err.Error())
		return nil
	}
	fmt.Fprintf(out, "Time: %f s\n", time.Since(start).Seconds())
	fmt.Fprintln(out, formatResponse(result))

	history_view, err := g.View("history")
	if err != nil {
		return err
	}

	history_item := fmt.Sprintf("%s %s %s\n", result.method, result.url, result.status)
	fmt.Fprintln(history_view, history_item)

	close(r)

    method_view.Clear()
    fmt.Fprintln(method_view, methods[active_method]) // CLEAR THE LOADING FROM TOP AND REWRITE REQUEST METHOD

	return nil
}

Can I achieve a behaviour where I can still mess up with the UI while the request is being made?
I also tried to create another channel, done, to notify the processRequest func, but I get the same results.

The problem with your current code is that while you're making the request concurrently, you're blocking on waiting for the result result := <-r. This is negating the point of running the request in a go-routine because you're not doing anything (such as handling UI events) in the meantime.

You could structure your code in a way that the response is handled in a go-routine, not just the request, then your application can be used like normal and the response can concurrently update the UI when the request's response is received at some point in the future.

In other words, processRequest should be run in a go-routine instead of httpRequest.