fix(devmgr): auto-reconnect stale LAN MQTT and recover startup race

LAN-mode-only printers (no Bambu cloud login) had two related failure
modes that left the user manually re-selecting the printer to make
Studio talk to it again. This commit fixes both -- they share the same
root surface (DeviceManager + TryLoadLastMachine), affect the same
users, and reproduce on the same workflow, so they ship together.

== Stale MQTT socket recovery (DeviceManagerRefresher::on_timer) ==

After idling, macOS App Nap, the local network stack, or the printer
can silently drop the MQTT-over-TLS TCP session. The next
publish_gcode() returns BAMBU_NETWORK_ERR_SEND_MSG_FAILED (-4) and the
user has to manually re-select the printer to trigger the
disconnect+reconnect path in DeviceManager::set_selected_machine.

on_timer's existing keep_alive() / refresh_connection() calls are
gated on is_user_login() and never run for LAN-only users. Add a
parallel branch that fires when all of these hold:

  - obj->is_lan_mode_printer() && obj->has_access_right()
  - obj->is_avaliable()       (bind_state == "free")
  - !obj->is_in_printing()    (don't clobber print UI mid-print)
  - !obj->is_connected()      (last MQTT push older than 30s)

When the gate passes, re-select the same machine id. That triggers
the same-id-LAN branch in set_selected_machine which runs
disconnect_printer -> reset -> connect -- the same path the manual
workaround takes. Throttled to one attempt per 10s, bumped only on a
successful set_selected_machine so a transient false return doesn't
delay the next chance to recover.

== Startup-race recovery (TryLoadLastMachine via SSDP) ==

TryLoadLastMachine::InnerLoad fires within milliseconds of app start,
before SSDP has announced the printer's current IP. If the cached
user_access_dev_ip is stale (slicer_uuid rotated since pairing, or
DHCP gave the printer a new IP), bind_detect returns -2 immediately,
erases user_access_dev_ip, and bails. The cloud fallback also fails
because the LAN printer isn't in the list yet. By the time SSDP
populates localMachineList ~1-3s later, no further InnerLoad retry
runs and the printer is discovered-but-not-selected (see upstream
issue #9445).

Add GUI_App::try_load_last_machine_on_alive(dev_id) and call it from
DeviceManager::on_machine_alive whenever an SSDP packet announces a
previously-paired printer. The retry's InnerLoad finds
user_access_dev_ip empty (the failed first attempt erased it) and
falls through to the dev->get_my_machine non-null branch in
GUI_App.cpp, which calls set_selected_machine directly. No second
bind_detect is spawned. The method self-filters on dev_id ==
get_user_last_machine() and no-ops if a machine is already selected,
so per-SSDP-packet invocation is cheap.

== Test plan ==

Stale-MQTT: idle the app >30min on macOS with a LAN-only printer.
Without patch, Send to Printer returns -4; with patch, the next 1Hz
refresher tick auto-reconnects and the send succeeds. Verify the log
line "LAN auto-reconnect: stale MQTT socket detected for dev_id=...".

Startup race: with a stale user_access_dev_ip (rotate slicer_uuid in
BambuStudio.conf, or power-cycle the router so SSDP is delayed),
launch Studio. Without patch the printer is never selected; with
patch the SSDP packet triggers a retry and selection succeeds.
Verify "try_load_last_machine_on_alive: SSDP-triggered retry for ...".

== Limitations ==

  - After studio inactivity (>15min), the first user action after
    wake may still see one failed send before stale-MQTT auto-
    reconnect runs on the next refresher tick. A subsequent send
    within 1s succeeds.
  - The 10s throttle is a function-static, not per-dev-id, so in
    multi-printer households a recent reconnect attempt on printer
    A can delay the next attempt on printer B by up to 10s.
  - TryLoadLastMachine's destructor joins local_bind_thread; an
    SSDP-triggered InnerLoad firing during app shutdown can stall
    the join 1-3s waiting for the bind_detect timeout.

Addresses upstream issue #9445.

Author: adele-with-a-b

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -279,6 +279,33 @@ namespace Slic3r
                 obj->erase_user_access_code();
                 obj->erase_user_access_dev_ip();
             }
+
+            // SSDP-driven retry of last-machine restore. The startup
+            // TryLoadLastMachine::InnerLoad path is racy for LAN-only users:
+            // if the cached user_access_dev_ip is stale (slicer_uuid rotated
+            // since pairing, or the printer is at a new IP) the initial
+            // bind_detect fails before SSDP can announce the printer's
+            // current IP, and the printer ends up in localMachineList but
+            // never selected.
+            //
+            // Recovery path: by the time SSDP populates localMachineList, the
+            // failed initial bind_detect has erased user_access_dev_ip. The
+            // retry's InnerLoad finds the encoded IP empty and falls through
+            // to the dev->get_my_machine(...) non-null branch (GUI_App.cpp
+            // around line 8429), which calls set_selected_machine directly.
+            // No second bind_detect is spawned.
+            //
+            // try_load_last_machine_on_alive runs on the wx UI thread (this
+            // function is dispatched via CallAfter from the SSDP listener),
+            // same thread as DeviceManagerRefresher::on_timer, so there is
+            // no concurrent invocation of set_selected_machine across the
+            // two LAN-recovery code paths in this commit.
+            //
+            // Called for every SSDP announcement (~5s/printer), not just
+            // first discovery. Cheap: try_load_last_machine_on_alive
+            // self-filters on dev_id == get_user_last_machine() and no-ops
+            // if a machine is already selected.
+            Slic3r::GUI::wxGetApp().try_load_last_machine_on_alive(dev_id);
         }
         catch (...) {
             ;
@@ -909,6 +936,69 @@ namespace Slic3r
             }
         }
 
+        // LAN-only stale-MQTT auto-reconnect.
+        //
+        // For LAN-mode-only printers (no Bambu cloud login), nothing else in this
+        // refresher runs: check_pushing() / refresh_connection() are gated on
+        // is_user_login() above, so the keep_alive() that would otherwise probe
+        // the MQTT session never fires. After the app sits idle long enough that
+        // macOS App Nap, the network stack, or the printer side closes the
+        // underlying TCP socket, the next publish_gcode() returns
+        // BAMBU_NETWORK_ERR_SEND_MSG_FAILED (-4) and the user has to manually
+        // re-select the printer to re-trigger the disconnect+reconnect path in
+        // DeviceManager::set_selected_machine.
+        //
+        // Detect the stale-socket condition for LAN printers and run the same
+        // reconnect path automatically. is_connected() returns false for LAN
+        // printers when last_update_time is older than DISCONNECT_TIMEOUT (30s),
+        // see MachineObject::is_connected in DeviceManager.cpp. Throttled to one
+        // attempt per LAN_RECONNECT_INTERVAL_MS so a powered-off printer doesn't
+        // get hammered.
+        //
+        // Skipped while a print is in progress (!is_in_printing()): MachineObject::reset()
+        // -- which set_selected_machine's same-id-LAN branch calls -- clobbers
+        // print_status / iot_print_status / subtask_ / print_json. Recovering MQTT
+        // mid-print would briefly blank the user's progress UI. The print itself
+        // continues on the printer regardless; we'll reconnect on the next tick
+        // after the print finishes.
+        //
+        // Skipped when bind_state != "free" (is_avaliable()): set_selected_machine
+        // would just return false because get_my_machine_list() filters out
+        // occupied printers, but the throttle would still bump and we'd log
+        // every 10s with no recovery possible.
+        if (obj->is_lan_mode_printer() && obj->has_access_right() &&
+            obj->is_avaliable() &&
+            !obj->is_in_printing() &&
+            !obj->is_connected())
+        {
+            constexpr int LAN_RECONNECT_INTERVAL_MS = 10 * 1000;
+            static std::chrono::system_clock::time_point last_lan_reconnect_attempt{};
+            const auto now = std::chrono::system_clock::now();
+            const auto since_last_attempt =
+                std::chrono::duration_cast<std::chrono::milliseconds>(now - last_lan_reconnect_attempt).count();
+
+            if (since_last_attempt > LAN_RECONNECT_INTERVAL_MS)
+            {
+                BOOST_LOG_TRIVIAL(info)
+                    << "LAN auto-reconnect: stale MQTT socket detected for dev_id="
+                    << BBLCrossTalk::Crosstalk_DevId(obj->get_dev_id())
+                    << ", re-selecting machine to trigger disconnect+reconnect";
+                // Re-selecting the same LAN id hits the same-id-LAN branch in
+                // set_selected_machine (DevManager.cpp), which calls
+                // m_agent->disconnect_printer(), obj->reset(), then
+                // obj->connect(...). This is the exact path the user takes
+                // manually via the Devices tab.
+                //
+                // Bump the throttle only on successful set_selected_machine.
+                // If it returns false (e.g. printer dropped from
+                // get_my_machine_list because bind_state flipped to
+                // "occupied" between the gate and this call), we don't want
+                // to wait 10s before the next chance to recover.
+                if (m_manager->set_selected_machine(obj->get_dev_id()))
+                    last_lan_reconnect_attempt = now;
+            }
+        }
+
         // certificate
         agent->install_device_cert(obj->get_dev_id(), obj->is_lan_mode_printer());
     }

src/slic3r/GUI/GUI_App.cpp

@@ -2650,6 +2650,32 @@ void GUI_App::on_start_subscribe_again(std::string dev_id)
     start_subscribe_timer->Start(5000, wxTIMER_ONE_SHOT);
 }
 
+void GUI_App::try_load_last_machine_on_alive(const std::string &dev_id)
+{
+    // Called from DeviceManager::on_machine_alive for every SSDP announcement
+    // (~5s/printer). Runs on the wx UI thread (the SSDP listener dispatches
+    // via CallAfter), same thread as DeviceManagerRefresher::on_timer, so
+    // there is no concurrent invocation of set_selected_machine between the
+    // SSDP-retry path here and the stale-MQTT-recovery path in on_timer.
+    if (dev_id.empty()) return;
+    if (!m_agent || !m_device_manager) return;
+
+    // Only retry for the machine the user had previously selected. Filter
+    // aggressively before doing anything observable so SSDP packets for
+    // other printers on the network are nearly free.
+    const auto &last = m_device_manager->get_user_last_machine();
+    if (last.empty() || last != dev_id) return;
+
+    // If a machine is already selected we have nothing to fix. InnerLoad
+    // would early-return anyway; we skip the call entirely to keep the
+    // log clean.
+    if (m_device_manager->get_selected_machine() != nullptr) return;
+
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": SSDP-triggered retry for "
+        << BBLCrossTalk::Crosstalk_DevId(dev_id);
+    m_load_last_machine.InnerLoad(m_agent, m_device_manager);
+}
+
 std::string GUI_App::get_local_models_path()
 {
     std::string local_path = "";

src/slic3r/GUI/GUI_App.hpp

@@ -365,6 +365,19 @@ class GUI_App : public wxApp
 public:
     //try again when subscription fails
     void            on_start_subscribe_again(std::string dev_id);
+
+    // SSDP-driven retry of TryLoadLastMachine::InnerLoad. Called from
+    // DeviceManager::on_machine_alive when an SSDP packet announces a
+    // previously-paired printer. Closes the startup race where the cached
+    // user_access_dev_ip is stale (e.g. slicer_uuid rotated since pairing
+    // so the encoded IP can't be decoded, or the printer is at a new IP)
+    // and the initial InnerLoad's bind_detect fails -- by retrying once
+    // the printer's actual current IP is known via SSDP, we let the LAN
+    // path complete instead of leaving the printer discovered-but-not-
+    // selected. Idempotent and cheap to call repeatedly: InnerLoad
+    // returns early if a machine is already selected.
+    void            try_load_last_machine_on_alive(const std::string &dev_id);
+
     std::string     get_local_models_path();
     bool            OnInit() override;
     int             OnExit() override;