Fix bridge transport and platform server reliability issues.

Connect to the mobile bridge asynchronously on startup, use non-blocking
reconnect retries, wrap delegated GenServer return tuples in Platform.Server,
and avoid spawn_link when raising macOS windows.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: dominicletz

lib/desktop/backend/wx.ex

@@ -184,10 +184,13 @@ defmodule Desktop.Backend.Wx do
       MacOS ->
         name = System.get_env("EMU", "beam.smp")
 
-        fn ->
-          System.cmd("open", ["-a", name], stderr_to_stdout: true, parallelism: true)
-        end
-        |> spawn_link()
+        spawn(fn ->
+          try do
+            System.cmd("open", ["-a", name], stderr_to_stdout: true, parallelism: true)
+          rescue
+            _ -> :ok
+          end
+        end)
 
       _ ->
         # Calling setFocus on wxDirDialog segfaults on macOS — handled above.

lib/desktop/bridge/transport.ex

@@ -81,22 +81,34 @@ defmodule Desktop.Bridge.Transport do
   def init(_opts) do
     port = String.to_integer(System.get_env("BRIDGE_PORT", "0"))
 
-    {socket, send} =
-      if port == 0 do
-        {Desktop.Bridge.Mock, &Desktop.Bridge.Mock.send/2}
-      else
-        {:ok, socket} =
-          :gen_tcp.connect(~c"127.0.0.1", port, packet: 4, active: true, mode: :binary)
+    if port == 0 do
+      {:ok,
+       %__MODULE__{
+         port: port,
+         socket: Desktop.Bridge.Mock,
+         send: &Desktop.Bridge.Mock.send/2
+       }}
+    else
+      {:ok,
+       %__MODULE__{
+         port: port,
+         socket: nil,
+         send: &:gen_tcp.send/2
+       }, {:continue, :connect}}
+    end
+  end
 
-        {socket, &:gen_tcp.send/2}
-      end
+  @impl true
+  def handle_continue(:connect, state = %__MODULE__{port: port}) do
+    case connect(port) do
+      {:ok, socket} ->
+        {:noreply, %__MODULE__{state | socket: socket}}
 
-    {:ok,
-     %__MODULE__{
-       port: port,
-       socket: socket,
-       send: send
-     }}
+      {:error, reason} ->
+        Logger.error("Bridge connection failed on startup: #{inspect(reason)}, retrying...")
+        Process.send_after(self(), :reconnect, 1_000)
+        {:noreply, state}
+    end
   end
 
   @impl true
@@ -199,25 +211,31 @@ defmodule Desktop.Bridge.Transport do
 
   def handle_info({:tcp_error, socket, reason}, state = %__MODULE__{socket: socket}) do
     Logger.error("Bridge connection failed: #{inspect(reason)}")
-    {:noreply, try_reconnect(state)}
+    Process.send_after(self(), :reconnect, 1_000)
+    {:noreply, %__MODULE__{state | socket: nil}}
   end
 
   def handle_info({:tcp_closed, socket}, state = %__MODULE__{socket: socket}) do
     Logger.error("Bridge connection closed")
-    {:noreply, try_reconnect(state)}
+    Process.send_after(self(), :reconnect, 1_000)
+    {:noreply, %__MODULE__{state | socket: nil}}
   end
 
-  def handle_info(_other, state), do: {:noreply, state}
-
-  defp try_reconnect(state = %__MODULE__{port: port, last_url: last_url}) do
-    case :gen_tcp.connect(~c"127.0.0.1", port, [packet: 4, active: true, mode: :binary], 1_000) do
+  def handle_info(:reconnect, state = %__MODULE__{port: port, last_url: last_url}) do
+    case connect(port) do
       {:ok, socket} ->
         if last_url, do: spawn(fn -> bridge_call(:wxWebView, :loadURL, [nil, last_url]) end)
-        %__MODULE__{state | socket: socket}
+        {:noreply, %__MODULE__{state | socket: socket}}
 
       {:error, _} ->
-        Process.sleep(1_000)
-        try_reconnect(state)
+        Process.send_after(self(), :reconnect, 1_000)
+        {:noreply, state}
     end
   end
+
+  def handle_info(_other, state), do: {:noreply, state}
+
+  defp connect(port) do
+    :gen_tcp.connect(~c"127.0.0.1", port, [packet: 4, active: true, mode: :binary], 1_000)
+  end
 end

lib/desktop/platform/server.ex

@@ -24,40 +24,56 @@ defmodule Desktop.Platform.Server do
   @impl true
   def handle_info(message, s = %__MODULE__{state: state, module: module}) do
     if function_exported?(module, :handle_event, 2) and is_tuple(message) do
-      case module.handle_event(message, state) do
-        {:noreply, new_state} -> {:noreply, %{s | state: new_state}}
-        other -> other
-      end
+      module.handle_event(message, state)
+      |> wrap_result(s)
     else
       dispatch_info(message, s)
     end
   end
 
   defp dispatch_info(message, s = %__MODULE__{state: state, module: module}) do
     if function_exported?(module, :handle_info, 2) do
-      case module.handle_info(message, state) do
-        {:noreply, new_state} -> {:noreply, %{s | state: new_state}}
-        other -> other
-      end
+      module.handle_info(message, state)
+      |> wrap_result(s)
     else
       {:noreply, s}
     end
   end
 
   @impl true
   def handle_cast(message, s = %__MODULE__{state: state, module: module}) do
-    case module.handle_cast(message, state) do
-      {:noreply, new_state} -> {:noreply, %{s | state: new_state}}
-      other -> other
-    end
+    module.handle_cast(message, state)
+    |> wrap_result(s)
   end
 
   @impl true
   def handle_call(message, from, s = %__MODULE__{state: state, module: module}) do
-    case module.handle_call(message, from, state) do
-      {:noreply, new_state} -> {:noreply, %{s | state: new_state}}
-      {:reply, reply, new_state} -> {:reply, reply, %{s | state: new_state}}
-      other -> other
+    module.handle_call(message, from, state)
+    |> wrap_result(s)
+  end
+
+  defp wrap_result(result, s) do
+    case result do
+      {:reply, reply, new_state} ->
+        {:reply, reply, %{s | state: new_state}}
+
+      {:reply, reply, new_state, extra} ->
+        {:reply, reply, %{s | state: new_state}, extra}
+
+      {:noreply, new_state} ->
+        {:noreply, %{s | state: new_state}}
+
+      {:noreply, new_state, extra} ->
+        {:noreply, %{s | state: new_state}, extra}
+
+      {:stop, reason, new_state} ->
+        {:stop, reason, %{s | state: new_state}}
+
+      {:stop, reason, reply, new_state} ->
+        {:stop, reason, reply, %{s | state: new_state}}
+
+      other ->
+        other
     end
   end
 end