Merge pull request #140 from bbangert/feat/espex-0.8-lazy-open

Bump espex to 0.8 + persist serial-proxy line settings

Author: bbangert

lib/universal_proxy/application.ex

@@ -44,6 +44,16 @@ defmodule UniversalProxy.Application do
         # top level so a restart/0 of the ESPHome subtree never closes its
         # DETS file. Holds the HA-provisioned API encryption key.
         UniversalProxy.ESPHome.PskStore,
+        # UART per-port line-settings store (DETS). Sits beside
+        # ConfigStore/PskStore at the top level so a restart/0 of the
+        # ESPHome subtree never closes its DETS file, since the writer
+        # (the ESPHome serial-proxy adapter) lives there. Remembers the
+        # last settings each port was successfully opened with, served
+        # back through the serial-proxy adapter's default_open_opts/1 so a
+        # client resuming after a restart without CONFIGURE gets the
+        # right baud rate instead of the espex 9600-8-N-1 fallback, and
+        # through Hardware.list_ports/0 for the Overview drawer display.
+        UniversalProxy.UART.SettingsStore,
         # Firmware update flow (ConfigStore + library Supervisor, wired
         # together so the snapshot lands before the library starts).
         UniversalProxy.FirmwareUpdate,

lib/universal_proxy/esphome/serial_proxy.ex

@@ -20,6 +20,25 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
   `SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE`. `UNSUBSCRIBE` halts forwarding
   again. Both are handled through `c:Espex.SerialProxy.request/2` and
   routed to the per-instance `Relay`.
+
+  espex 0.8 tracks subscribe *intent* per connection rather than a
+  one-shot stash: the client's first operation of any kind (write,
+  subscribe, modem pins, flush) against an advertised-but-unopened
+  instance lazily opens it via `open/3`, and a previously-set subscribe
+  intent is reattached (another `request/2` call) after *every*
+  successful open — whether that open was triggered by CONFIGURE or by
+  the lazy path. This lets a client resume traffic (e.g. Home Assistant
+  writing to a Zigbee coordinator, or re-subscribing) after a proxy
+  restart without re-sending CONFIGURE first.
+
+  ## Persisted line settings
+
+  A lazily-opened instance has no CONFIGURE to draw options from, so
+  `default_open_opts/1` below serves the settings the port was last
+  successfully opened with (persisted in `SettingsStore`) instead of
+  espex's 9600-8-N-1 fallback. Real ESPHome hardware retains its UART
+  settings across a client reconnect, so this keeps a resumed connection
+  talking at the baud rate the attached device actually expects.
   """
 
   @behaviour Espex.SerialProxy
@@ -30,6 +49,7 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
   alias UniversalProxy.ESPHome.SerialProxy.Relay
   alias UniversalProxy.Hardware
   alias UniversalProxy.UART
+  alias UniversalProxy.UART.SettingsStore
 
   @impl true
   def list_instances do
@@ -43,13 +63,15 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
   @impl true
   def open(instance, opts, subscriber) do
     case Enum.at(inventory(), instance) do
-      %{path: path, friendly_name: friendly_name} ->
+      %{id: id, path: path, friendly_name: friendly_name} ->
         with {:ok, _pid} <- UART.open(path, Keyword.put(opts, :friendly_name, friendly_name)),
              {:ok, relay} <- start_relay_or_close(path, friendly_name, subscriber) do
           Logger.info(
             "ESPHome serial proxy opened instance #{instance} (#{friendly_name} @ #{path}, #{opts[:speed]} baud)"
           )
 
+          persist_opts(id, opts)
+
           {:ok, {relay, path}}
         else
           {:error, reason} = err ->
@@ -65,6 +87,20 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
     end
   end
 
+  @impl true
+  def default_open_opts(instance) do
+    # espex 0.8 calls this when a client operates on an advertised
+    # instance without a prior CONFIGURE on this connection (e.g. HA
+    # resuming after a proxy restart). Serve the settings the port was
+    # last successfully opened with; fall back to espex's 9600-8-N-1.
+    with %{id: id} <- Enum.at(inventory(), instance),
+         opts when is_list(opts) <- get_stored_opts(id) do
+      opts
+    else
+      _ -> Espex.SerialProxy.default_open_opts()
+    end
+  end
+
   # If the UART port opened but the relay can't start, the port would stay
   # registered against this connection forever — release it before bubbling
   # the error.
@@ -99,9 +135,11 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
     end
   end
 
-  # Espex.Connection calls set_modem_pins/3 and get_modem_pins/1 unguarded
-  # (no `function_exported?` check), so we provide stubs even though both
-  # are declared `@optional_callbacks` in `Espex.SerialProxy`.
+  # espex 0.8 guards both set_modem_pins/3 and get_modem_pins/1 with
+  # function_exported? and would otherwise fall back to its own
+  # omitted-callback default (all lines low / no-op). We keep these stubs
+  # anyway to answer NOT_SUPPORTED explicitly rather than relying on that
+  # fallback.
   @impl true
   def set_modem_pins(_handle, _rts, _dtr), do: {:error, :not_supported}
 
@@ -143,11 +181,37 @@ defmodule UniversalProxy.ESPHome.SerialProxy do
     end)
     |> Enum.map(fn port ->
       %{
+        id: port.id,
         path: port.tty_name,
         friendly_name: port.ha_name,
         port_type: port.kind
       }
     end)
     |> Enum.sort_by(& &1.friendly_name)
   end
+
+  # Best-effort: a `SettingsStore` hiccup (down, wedged, or DETS write
+  # failure) must not fail an otherwise-good open. Follows this project's
+  # public-API `catch :exit` idiom (CLAUDE.md) — a wedged store degrades
+  # to "settings not persisted" rather than failing the connection.
+  defp persist_opts(id, opts) do
+    case SettingsStore.put_opts(id, opts) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        Logger.warning("ESPHome serial settings store write failed for #{id}: #{inspect(reason)}")
+    end
+  catch
+    :exit, reason ->
+      Logger.warning("ESPHome serial settings store unavailable for #{id}: #{inspect(reason)}")
+  end
+
+  # Same idiom as persist_opts/2: a down/wedged store must degrade to the
+  # espex default, not crash the espex connection process.
+  defp get_stored_opts(id) do
+    SettingsStore.get_opts(id)
+  catch
+    :exit, _ -> nil
+  end
 end

lib/universal_proxy/hardware.ex

@@ -175,6 +175,9 @@ defmodule UniversalProxy.Hardware do
     * `:slots` — explicit list of slot bus paths (overrides the
       target-based mapping; pass `nil` for dynamic mode)
     * `:saved_configs` — pre-built `%{serial_number => config}` map
+    * `:line_settings` — pre-built `%{port_id => keyword()}` map of
+      persisted UART line settings (see
+      `UniversalProxy.UART.SettingsStore.all_opts/1`)
     * `:in_use_ports` — pre-built `MapSet` of currently-opened tty
       basenames
     * `:zwave_claim` — the Z-Wave proxy's port claim
@@ -197,6 +200,8 @@ defmodule UniversalProxy.Hardware do
         end)
       end)
 
+    line_settings = Keyword.get_lazy(opts, :line_settings, &safe_line_settings/0)
+
     usage = %{
       in_use_ports:
         Keyword.get_lazy(opts, :in_use_ports, fn ->
@@ -211,11 +216,19 @@ defmodule UniversalProxy.Hardware do
     slots = Keyword.get(opts, :slots, target_slots())
 
     case slots do
-      nil -> dynamic_listing(enumerated, bus_paths, saved, usage)
-      slots -> slot_listing(slots, enumerated, bus_paths, saved, usage)
+      nil -> dynamic_listing(enumerated, bus_paths, saved, usage, line_settings)
+      slots -> slot_listing(slots, enumerated, bus_paths, saved, usage, line_settings)
     end
   end
 
+  # A wedged/absent SettingsStore must degrade to "no settings shown", not
+  # take down the caller (public-API catch :exit idiom, CLAUDE.md).
+  defp safe_line_settings do
+    UART.SettingsStore.all_opts()
+  catch
+    :exit, _ -> %{}
+  end
+
   @doc """
   Map of `{slot_sub, vendor_id, product_id} => tty_basename` for every
   currently-connected USB serial adapter. ESPHome consumers use this to
@@ -357,7 +370,7 @@ defmodule UniversalProxy.Hardware do
 
   # -- Slot mode (per-target, every port shows) ------------------------
 
-  defp slot_listing(slots, enumerated, bus_paths, saved, usage) do
+  defp slot_listing(slots, enumerated, bus_paths, saved, usage, line_settings) do
     tty_by_bus_path = Map.new(bus_paths, fn {tty, bus} -> {bus, tty} end)
     known_slots = MapSet.new(slots)
 
@@ -371,7 +384,7 @@ defmodule UniversalProxy.Hardware do
 
           tty_name ->
             info = Map.get(enumerated, tty_name, %{})
-            build_port(tty_name, info, slot_sub, saved, usage, idx)
+            build_port(tty_name, info, slot_sub, saved, usage, line_settings, idx)
         end
       end)
 
@@ -384,23 +397,23 @@ defmodule UniversalProxy.Hardware do
       |> Enum.with_index(length(slots) + 1)
       |> Enum.map(fn {{tty_name, bus_path}, idx} ->
         info = Map.get(enumerated, tty_name, %{})
-        build_port(tty_name, info, bus_path, saved, usage, idx)
+        build_port(tty_name, info, bus_path, saved, usage, line_settings, idx)
       end)
 
     declared ++ bonus
   end
 
   # -- Dynamic mode (host / unknown target) ----------------------------
 
-  defp dynamic_listing(enumerated, bus_paths, saved, usage) do
+  defp dynamic_listing(enumerated, bus_paths, saved, usage, line_settings) do
     enumerated
     |> Enum.filter(fn {name, _} -> usb_serial?(name) end)
     |> Enum.map(fn {name, info} -> {name, info, Map.get(bus_paths, name)} end)
     |> Enum.sort_by(fn {name, _info, bus_path} -> {bus_path || "~", name} end)
     |> Enum.with_index(1)
     |> Enum.map(fn {{name, info, bus_path}, idx} ->
       slot_sub = bus_path || name
-      build_port(name, info, slot_sub, saved, usage, idx)
+      build_port(name, info, slot_sub, saved, usage, line_settings, idx)
     end)
   end
 
@@ -458,7 +471,7 @@ defmodule UniversalProxy.Hardware do
 
   # -- Port shape ------------------------------------------------------
 
-  defp build_port(tty_name, info, slot_sub, saved, usage, idx) do
+  defp build_port(tty_name, info, slot_sub, saved, usage, line_settings, idx) do
     vid = info[:vendor_id]
     pid = info[:product_id]
     serial = info[:serial_number]
@@ -470,6 +483,7 @@ defmodule UniversalProxy.Hardware do
     name = pick_name(saved_cfg, device_info, info)
     vendor = pick_vendor(device_info, info)
     chip = pick_chip(device_info, info)
+    line = Map.get(line_settings, port_id(slot_sub))
 
     %{
       id: port_id(slot_sub),
@@ -494,12 +508,27 @@ defmodule UniversalProxy.Hardware do
       locked: classification.locked,
       user: user,
       user_href: nil,
-      baud: nil,
       throughput: %{in: 0, out: 0, unit: "B/s"},
       errors: 0,
       since: nil,
       notes: classification.notes
     }
+    |> Map.merge(line_setting_fields(line))
+  end
+
+  # No persisted entry (never opened, or store unavailable) → `baud: nil`,
+  # which `fact_rows/1` in the Overview LiveView treats as "hide the Serial
+  # settings row". `parity` MUST be a string, never an atom — the LiveView
+  # calls `String.first/1` on it.
+  defp line_setting_fields(nil), do: %{baud: nil, data_bits: nil, stop_bits: nil, parity: nil}
+
+  defp line_setting_fields(opts) do
+    %{
+      baud: opts[:speed],
+      data_bits: opts[:data_bits],
+      stop_bits: opts[:stop_bits],
+      parity: to_string(opts[:parity] || :none)
+    }
   end
 
   # Who holds this tty open, if anyone. The Z-Wave proxy owns its port