How to init a node long running process through Port?

I’m trying to stablish a long term node process using Port, but the gen server crashs saying

erlang.erl:4716: :erlang.open_port({:spawn, "ts-node c:/Users/pedri/Desktop/ashandphoenix/assets/js/pixparser.ts"}, [:binary, :exit_status])
            (testespay 0.1.0) lib/testespay/genservers/nodepix_processor.ex:17: Testespay.Genservers.NodepixProcessor.init/1

I’m able to open the process using {:spawn, "cmd /c ts-node.cmd #{@node_script_path}"}, on my init callback, but the process doesnt receive any messages, so i dont know if some logic is wrong on my gen server, or opening the process with this command blocks the connection in some way

full code:

defmodule Testespay.Genservers.NodepixProcessor do
  require Logger
  use GenServer

  @node_script_path Path.join([File.cwd!(), "assets", "js", "pixparser.ts"])

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def parse_pix(payload) do
    GenServer.call(__MODULE__, {:parse_pix, payload})
  end

  def init(_opts) do
    # Remova a chamada System.cmd desnecessária
    Logger.debug(@node_script_path)

    port = Port.open(
      {:spawn, "cmd /c ts-node.cmd #{@node_script_path}"},
      [:binary, :exit_status]
    )

    {:ok, %{port: port, buffer: "", current_ref: nil}}
  end
  def handle_call({:parse_pix, payload}, from, state) do
    # Envia o payload para o processo Node
    Port.command(state.port, "#{Jason.encode!(payload)}\n")
    {:noreply, %{state | current_ref: from}}
  end

  def handle_info({port, {:data, data}}, %{port: port, buffer: buffer} = state) do
    new_buffer = buffer <> data

    case String.split(new_buffer, "\n", parts: 2) do
      [message, rest] ->
        handle_node_message(message, state)
        {:noreply, %{state | buffer: rest}}

      _ ->
        {:noreply, %{state | buffer: new_buffer}}
    end
  end

  defp handle_node_message("READY", _state), do: :ok  # Ignora a mensagem de inicialização

  defp handle_node_message(message, %{current_ref: current_ref} = state) do
    case Jason.decode(message) do
      {:ok, %{"status" => "success"} = response} ->
        GenServer.reply(current_ref, {:ok, response})

      {:ok, %{"status" => "error"} = error} ->
        GenServer.reply(current_ref, {:error, error})

      _ ->
        GenServer.reply(current_ref, {:error, :invalid_response})
    end
  end
end