Add Missing Includes to the Plugin JSON Depth Test

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,9 +204,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+        if (!is_core_xy && (axis == "Y" || axis == "Z"))
             dir = -dir;
-        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -216,9 +215,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -1.0 * input_val;
-    }
+    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        value = -input_val;
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -239,11 +237,10 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0) {
+    if (rtn == 0)
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    } else {
+    else
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
-    }
     return rtn;
 }
 
@@ -589,21 +586,8 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    // dispatch_start() moves out of `params`, so snapshot the diagnostic fields first;
-    // logging them after the call would print empty strings.
-    const bool        try_emmc_print = params.try_emmc_print;
-    const std::string dev_ip         = params.dev_ip;
-    const std::string dev_id         = params.dev_id;
-
-    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
-    if (result != 0) {
-        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
-            << ", try_emmc_print=" << try_emmc_print
-            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
-            << ", dev_ip=" << dev_ip << ", dev_id=" << dev_id;
-    }
-    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -110,7 +110,6 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -288,14 +288,9 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    const MoonrakerDeviceInfo info = snapshot_device_info();
-
-    if (info.dev_ip.empty()) {
+    if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";
         return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
@@ -304,11 +299,11 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
     // Build a CrealityPrint helper so we can use its model detection + WS helpers
     // (added in upstream PR #13291).
     DynamicPrintConfig cfg;
-    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + device_info.dev_ip));
     cfg.set_key_value("print_host_webui",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_cafile",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_port",              new ConfigOptionString(""));
-    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(device_info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,7 +37,7 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override { shutdown(); }
+    ~CrealityPrintAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -12,10 +12,6 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <chrono>
-#include <condition_variable>
-#include <deque>
-#include <functional>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -24,56 +20,6 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
-class Http;
-
-bool moonraker_is_light_name(const std::string& name);
-// Direction encoded by a light name: +1 turns on, -1 turns off, 0 is an ambiguous toggle.
-// e.g. LIGHT_ON -> +1, LIGHT_OFF -> -1, LIGHT -> 0.
-int moonraker_light_name_direction(const std::string& name);
-
-struct MoonrakerWebcamSelection
-{
-    std::string      url;
-    CameraStreamMode mode = CameraStreamMode::none;
-    std::string      name;
-    std::string      error;  // set when no selectable webcam was found
-};
-
-// Selects a webcam from a parsed /server/webcams/list response (the top-level JSON or its
-// "result" value). Returns true and fills url/mode/name on success; on failure returns
-// false and sets error.
-bool moonraker_parse_webcam_list(const nlohmann::json& response, const std::string& base_url,
-                                 MoonrakerWebcamSelection& out);
-
-class MoonrakerWebsocket
-{
-public:
-    enum class ReadResult
-    {
-        message,
-        timeout,
-        closed,
-        error,
-    };
-
-    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
-    ~MoonrakerWebsocket();
-
-    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
-    void tls_handshake(const std::string& host);
-    void handshake(const std::string& host, const std::string& target);
-    void text(bool enabled);
-    void write(const std::string& body);
-    ReadResult read(std::string& payload, std::string& error_message);
-    void close();
-    void expires_after(std::chrono::seconds timeout);
-    void abort();
-
-private:
-    struct Impl;
-    std::unique_ptr<Impl> m_impl;
-};
-
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -119,24 +65,12 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    CameraStreamMode get_camera_stream_mode() const override;
-    std::string get_camera_url() const override;
 
-    // Called by the fetch-thread RAII guard when a background filament fetch finishes.
-    // Serialized with the reservation so shutdown()'s wait cannot miss the transition to 0.
-    void release_fetch_slot() noexcept;
+    // Pull-mode agent (on-demand filament sync)
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
 protected:
-    struct ConnectionSettings
-    {
-        std::string dev_id;
-        std::string base_url;
-        std::string api_key;
-        bool        use_ssl = false;
-        std::string ca_file;
-    };
-
     struct MoonrakerDeviceInfo
     {
         std::string dev_id;
@@ -148,9 +82,7 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
-        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
-        std::string ca_file;
     } device_info;
 
     // Tray data for AMS payload building
@@ -168,29 +100,12 @@ protected:
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
-    ConnectionSettings get_connection_settings() const;
-    // Copy of the mutable connection state, taken under connect_mutex. Background threads
-    // must use this instead of reading device_info directly.
-    MoonrakerDeviceInfo snapshot_device_info() const;
-    void configure_http(Http& http, const ConnectionSettings& connection) const;
-    static float parse_nozzle_diameter(const nlohmann::json& response);
+    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
-    // Detached fetch threads hold a raw `this`; shutdown() waits for this to reach 0.
-    std::atomic<int> filament_fetch_in_flight{0};
-
-    // Idempotent teardown; must be called from the most-derived destructor.
-    void shutdown();
-    std::atomic<bool> shutting_down{false};
-
-    // Serializes the shutting_down check with the in-flight reservation.
-    std::mutex fetch_lifecycle_mutex;
-    std::condition_variable fetch_done_cv;  // notified when filament_fetch_in_flight reaches 0
-
     // Helpers
     bool        is_numeric(const std::string& value);
     std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
@@ -203,30 +118,13 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
-    // Send a G-code script via Moonraker (/printer/gcode/script)
-    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
-    bool send_gcode(const std::string& dev_id, const std::string& gcode,
-                    const ConnectionSettings& connection) const;
-    bool post_print_action(const std::string& action) const;
-    bool post_print_action(const std::string& action,
-                           const ConnectionSettings& connection) const;
-
-    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
-
-    virtual void on_status_loop_tick(const std::string& dev_id) {}
-
-    // Queue work that may use agent state. The command worker is joined during
-    // destruction, so queued commands cannot outlive the agent.
-    void enqueue_command(std::function<void()> fn);
-    mutable std::recursive_mutex connect_mutex;
-
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
+    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -234,48 +132,37 @@ private:
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
-
-    // Self-contained snapshot of the message callbacks. Async completions capture this
-    // by value so they never dereference `this` after the agent may have been destroyed.
-    struct MessageRouter
-    {
-        OnMessageFn   local_fn;
-        OnMessageFn   cloud_fn;
-        QueueOnMainFn queue_fn;
-        std::string   dev_id;
-
-        void deliver(std::string payload) const;
-    };
-
-    MessageRouter make_message_router(const std::string& dev_id) const;
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
+    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
     void stop_status_stream();
-    void run_status_stream(std::string dev_id, ConnectionSettings connection);
-    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
-    void refresh_thumbnail_url(const ConnectionSettings& connection);
+    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void handle_ws_message(const std::string& dev_id, const std::string& payload);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
+    // Print control helpers
+    int pause_print(const std::string& dev_id);
+    int resume_print(const std::string& dev_id);
+    int cancel_print(const std::string& dev_id);
+
     // File upload
     bool upload_gcode(const std::string& local_path, const std::string& filename,
-                      const ConnectionSettings& connection,
+                      const std::string& base_url, const std::string& api_key,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
+    // JSON-RPC helper
+    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+                              const nlohmann::json& request, std::string& response) const;
+
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   ConnectionSettings connection,
+                                   const std::string& base_url,
+                                   const std::string& api_key,
                                    uint64_t generation);
 
-    // why: a printer with no /server/webcams/list entry can still name its stream directly;
-    // subclasses (e.g. printers with a fixed webcam path) can override this instead.
-    virtual std::string webcam_stream_override(const std::string& base_url) const { return {}; }
-    void refresh_webcam_info() const;
-    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
-
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -301,43 +188,15 @@ private:
 
     mutable std::recursive_mutex payload_mutex;
     nlohmann::json     status_cache;
-    // note: guarded by payload_mutex; filled by refresh_thumbnail_url(), empty url = looked up, none found
-    std::string        thumbnail_filename;
-    std::string        thumbnail_url;
-    mutable std::string        webcam_stream_url;
-    mutable CameraStreamMode   webcam_stream_mode = CameraStreamMode::none;
-    // Next time the status loop may look the webcam up again (steady_clock ms).
-    mutable std::atomic<uint64_t> webcam_info_next_attempt_ms{0};
-    unsigned            thumbnail_lookup_attempts = 0;
-
-    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 30000;
-    static constexpr uint64_t WEBCAM_INFO_FAILURE_BACKOFF_MS  = 60000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
-    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
-    // stop_status_stream() invokes ws_abort_io to wake a blocked synchronous
-    // ws.read()/ws.write()/handshake in run_status_stream(): ws_stop is only
-    // observed between reads, and Beast's expires_after() does not bound
-    // synchronous operations.
-    std::mutex             ws_abort_mutex;
-    std::function<void()>  ws_abort_io;  // guarded by ws_abort_mutex
-
-    // Interrupts the exponential reconnect backoff in run_status_stream() when stopping.
-    std::mutex              ws_wait_mutex;
-    std::condition_variable ws_wait_cv;
-
-    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
-    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
-    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
-    std::atomic<uint64_t> ams_last_fetch_ms{0};
-
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -347,13 +206,7 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-
-    void run_command_worker();
-    std::thread cmd_thread;
-    std::deque<std::function<void()>> cmd_queue;
-    std::mutex cmd_mutex;
-    std::condition_variable cmd_cv;
-    bool cmd_stop = false;
+    std::recursive_mutex   connect_mutex;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,24 +2,18 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
 #include "libslic3r/Preset.hpp"
-#include <cstddef>
-#include <exception>
 #include <map>
-#include <mutex>
 #include <sstream>
-#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -40,26 +34,6 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const std::string& key, int fallback)
-{
-    auto it = obj.find(key);
-    return (it != obj.end() && it->is_number_integer()) ? it->get<int>() : fallback;
-}
-
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -73,166 +47,51 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
+    std::string error;
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-{
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
-    ConnectionSettings connection = get_connection_settings();
-    std::string        model_id;
-    std::string        model_name;
+    // 1. Fetch device info and infer series_id
+    std::string series_id;
     {
-        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
-        model_id   = device_info.model_id;
-        model_name = device_info.model_name;
-    }
-
-    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    InFlightGuard guard{*this};
-    std::thread([this, guard = std::move(guard), connection = std::move(connection), model_id, model_name]() mutable {
-        try {
-            std::string error;
-
-            // 1. Fetch device info and infer series_id
-            std::string series_id;
-            {
-                MoonrakerDeviceInfo info;
-                if (fetch_device_info(connection, info, error)) {
-                    series_id = infer_series_id(info.model_id, info.dev_name);
-                }
-            }
-            if (series_id.empty()) {
-                // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-                series_id = infer_series_id(model_id, model_name);
-            }
-
-            // 2. Fetch filament dictionary
-            QidiFilamentDict dict;
-            if (!fetch_filament_dict(connection, dict, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-            }
-
-            // 3. Fetch slot info and build AmsTrayData directly
-            std::vector<AmsTrayData> trays;
-            int box_count = 0;
-            if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
-                return;
-            }
-
-            // 4. Build the AMS payload
-            build_ams_payload(box_count, box_count * 4 - 1, trays);
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception";
+        MoonrakerDeviceInfo info;
+        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
+            series_id = infer_series_id(info.model_id, info.dev_name);
         }
-    }).detach();
+    }
+    if (series_id.empty()) {
+        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+        series_id = infer_series_id(device_info.model_id, device_info.model_name);
+    }
+
+    // 2. Fetch filament dictionary
+    QidiFilamentDict dict;
+    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
+    }
+
+    // 3. Fetch slot info and build AmsTrayData directly
+    std::vector<AmsTrayData> trays;
+    int                      box_count = 0;
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+        return false;
+    }
+
+    // 4. Build the AMS payload
+    build_ams_payload(box_count, box_count * 4 - 1, trays);
     return true;
 }
 
-bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-{
-    // enable_box mirrors task_use_ams: engage the multi-color box only when this
-    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
-    // if firmware treats enable_box as "a box exists" rather than "use it this job",
-    // switch this gate to HasAms()/box_count instead.)
-    const int         enable = params.task_use_ams ? 1 : 0;
-    const std::string dev_id = get_connection_settings().dev_id;
-
-    // Build one gcode/script request instead of N blocking HTTP calls: apply_box_mapping
-    // runs on the caller's (GUI) thread before the print starts, so per-tool round trips
-    // would freeze the UI.
-    std::string script = "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable);
-
-    // When the box isn't used this job, leave the existing value_t<tool> slot
-    // assignments untouched (enable_box=0 is enough to disengage it).
-    if (enable) {
-        if (params.ams_mapping.empty()) {
-            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
-        } else {
-            // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
-            // physical box slot (-1 = unmapped). Mirror it onto value_t<tool>.
-            auto mapping = nlohmann::json::parse(params.ams_mapping, nullptr, /*allow_exceptions*/ false);
-            if (mapping.is_discarded() || !mapping.is_array()) {
-                BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: invalid ams_mapping: " << params.ams_mapping;
-                return false;
-            }
-            for (size_t tool = 0; tool < mapping.size(); ++tool) {
-                if (!mapping[tool].is_number_integer())
-                    continue;
-                const int slot = mapping[tool].get<int>();
-                if (slot < 0)
-                    continue; // unmapped filament — skip
-                script += "\nSAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
-                          " VALUE=\"'slot" + std::to_string(slot) + "'\"";
-            }
-        }
-    }
-
-    if (!send_gcode(dev_id, script)) {
-        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to send box mapping";
-        return false;
-    }
-    return true;
-}
-
-int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
-}
-
-int QidiPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_print(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    // A failed box mapping is a send failure, not an upload failure.
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print_with_record(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_sdcard_print(std::move(params), update_fn, cancel_fn);
-}
-
-bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+                                       const std::string&        api_key,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -242,9 +101,8 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -269,12 +127,22 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         return false;
     }
 
-    nlohmann::json status;
-    nlohmann::json variables;
-    if (!parse_slot_response(response_body, status, variables, error))
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
         return false;
+    }
 
-    box_count = read_int_or(variables, "box_count", 1);
+    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].contains("variables")) {
+        error = "Unexpected JSON structure";
+        return false;
+    }
+
+    auto& variables = json["result"]["status"]["save_variables"]["variables"];
+    auto& status    = json["result"]["status"];
+
+    box_count = variables.value("box_count", 1);
     if (box_count < 0) {
         box_count = 0;
     }
@@ -297,9 +165,9 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
-        const int filament_type   = read_int_or(variables, "filament_slot" + std::to_string(i), 1);
-        const int vendor_type     = read_int_or(variables, "vendor_slot" + std::to_string(i), 0);
+        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
+        const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
         std::string box_stepper_key = "box_stepper slot" + std::to_string(i);
@@ -307,7 +175,7 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         if (status.contains(box_stepper_key)) {
             auto& box_stepper = status[box_stepper_key];
             if (box_stepper.contains("runout_button") && !box_stepper["runout_button"].is_null()) {
-                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
+                int runout_button = box_stepper["runout_button"].template get<int>();
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -347,45 +215,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     return true;
 }
 
-bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           nlohmann::json&    status,
-                                           nlohmann::json&    variables,
-                                           std::string&       error)
-{
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    if (json.is_discarded()) {
-        error = "Invalid JSON response";
-        return false;
-    }
-
-    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
-        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
-        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
-        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
-        // why: Qidi firmware may send null here, but json::value() throws for it.
-        error = "Unexpected JSON structure: save_variables.variables must be an object";
-        return false;
-    }
-
-    status    = json["result"]["status"];
-    variables = status["save_variables"]["variables"];
-    return true;
-}
-
-bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+                                           const std::string& api_key,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,8 +3,6 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "bambu_networking.hpp"
-#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -16,7 +14,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override { shutdown(); }
+    ~QidiPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -24,23 +22,7 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
-    static bool parse_slot_response(const std::string& response_body,
-                                    nlohmann::json&    status,
-                                    nlohmann::json&    variables,
-                                    std::string&       error);
-
-    // Print operations — emit QiDi multi-color box config, then delegate to base.
-    int start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-    int start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-
-    FilamentSyncMode get_filament_sync_mode() const override;
-
 private:
-    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
-    // Returns false if any command fails (caller should abort the print).
-    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -48,13 +30,14 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const ConnectionSettings& connection,
+    bool fetch_slot_info(const std::string&        base_url,
+                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,19 +2,11 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <cstdint>
-#include <exception>
-#include <mutex>
-#include <sstream>
-#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -26,77 +18,6 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
-constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
-
-int64_t now_ms()
-{
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::steady_clock::now().time_since_epoch()).count();
-}
-
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const char* key, int fallback)
-{
-    auto it = obj.find(key);
-    return (it != obj.end() && it->is_number_integer()) ? it->get<int>() : fallback;
-}
-
-std::vector<std::string> read_string_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<std::string> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_string() ? v.get<std::string>() : std::string{});
-    return out;
-}
-
-std::vector<bool> read_bool_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<bool> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_boolean() ? v.get<bool>() : false);
-    return out;
-}
-
-// Parse a hex colour, stopping at the first non-hex character. std::stoul throws on
-// empty/non-hex input, which must not escape the detached fetch thread.
-unsigned int parse_hex_color(const std::string& hex)
-{
-    unsigned int value = 0;
-    for (char c : hex) {
-        int digit;
-        if (c >= '0' && c <= '9')
-            digit = c - '0';
-        else if (c >= 'a' && c <= 'f')
-            digit = c - 'a' + 10;
-        else if (c >= 'A' && c <= 'F')
-            digit = c - 'A' + 10;
-        else
-            break;
-        value = (value << 4) | static_cast<unsigned int>(digit);
-    }
-    return value;
-}
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -119,16 +40,14 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
             filaments.get_preset_base(p) == &p && p.config.opt_string("filament_vendor", 0u) == vendor_name &&
             p.config.opt_string("filament_type", 0u) == filament_type) {
             // The printer returns RGBA in the format RRGGBBAA, but profiles store color as #RRGGBB,
-            // so we must remove # and ignore alpha channel for distance calculation. Firmware
-            // colours are untrusted; parse_hex_color tolerates empty/non-hex instead of throwing.
-            unsigned int target_color_value =
-                parse_hex_color(color_rgba.substr(0, color_rgba.size() >= 2 ? color_rgba.size() - 2 : 0));
+            // so we must remove # and ignore alpha channel for distance calculation
+            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
 
             std::string  p_color = p.config.opt_string("default_filament_colour", 0u);
-            unsigned int p_color_value = 0;
+            unsigned int p_color_value;
             if (!p_color.empty()) {
-                size_t hash_pos = p_color.find("#");
-                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
+                size_t       hash_pos = p_color.find("#");
+                p_color_value         = std::stoul(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0), nullptr, 16);
             } else {
                 // Default to black if no color specified in profile. Assume other profiles might be a closer color match.
                 // Could be a problem if the target color is also black and there exist a specific profile for that type, vendor and color
@@ -155,31 +74,6 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
-void SnapmakerPrinterAgent::start_camera_monitor()
-{
-    enqueue_command([this] {
-        send_ws_rpc("camera.start_monitor",
-                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
-    });
-    m_camera_last_fire_ms.store(now_ms());
-}
-
-void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
-{
-    (void) dev_id;
-    const int64_t last = m_camera_last_fire_ms.load();
-    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
-        start_camera_monitor();
-    }
-}
-
-int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
-{
-    (void) dev_id;
-    start_camera_monitor();
-    return BAMBU_NETWORK_SUCCESS;
-}
-
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -215,170 +109,127 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    (void) dev_id;
-    if (sync_mode != get_filament_sync_mode())
+    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+
+    std::string response_body;
+    bool        success = false;
+    std::string http_error;
+
+    auto http = Http::get(url);
+    if (!device_info.api_key.empty()) {
+        http.header("X-Api-Key", device_info.api_key);
+    }
+    http.timeout_connect(5)
+        .timeout_max(10)
+        .on_complete([&](std::string body, unsigned status) {
+            if (status == 200) {
+                response_body = body;
+                success       = true;
+            } else {
+                http_error = "HTTP error: " + std::to_string(status);
+            }
+        })
+        .on_error([&](std::string body, std::string err, unsigned status) {
+            http_error = err;
+            if (status > 0) {
+                http_error += " (HTTP " + std::to_string(status) + ")";
+            }
+        })
+        .perform_sync();
+
+    if (!success) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
-
-    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
-    // device_info meanwhile.
-    const ConnectionSettings connection = get_connection_settings();
-
-    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
     }
 
-    InFlightGuard guard{*this};
-    std::thread([this, guard = std::move(guard), connection]() {
-        try {
-            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        return false;
+    }
 
-            std::string response_body;
-            bool success = false;
-            std::string http_error;
+    // Navigate to result.status.print_task_config
+    if (!json.contains("result") || !json["result"].contains("status") ||
+        !json["result"]["status"].contains("print_task_config")) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
+        return false;
+    }
 
-            auto http = Http::get(url);
-            configure_http(http, connection);
-            if (!connection.api_key.empty()) {
-                http.header("X-Api-Key", connection.api_key);
-            }
-            http.timeout_connect(5)
-                .timeout_max(10)
-                .on_complete([&](std::string body, unsigned status) {
-                    if (status == 200) {
-                        response_body = body;
-                        success       = true;
-                    } else {
-                        http_error = "HTTP error: " + std::to_string(status);
-                    }
-                })
-                .on_error([&](std::string body, std::string err, unsigned status) {
-                    http_error = err;
-                    if (status > 0) {
-                        http_error += " (HTTP " + std::to_string(status) + ")";
-                    }
-                })
-                .perform_sync();
+    auto& ptc = json["result"]["status"]["print_task_config"];
 
-            if (!success) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
-                return;
-            }
+    // Read parallel arrays from print_task_config
+    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-            if (json.is_discarded()) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-                return;
-            }
+    const int slot_count = static_cast<int>(filament_exist.size());
+    if (slot_count == 0) {
+        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+        return false;
+    }
 
-            // Navigate to result.status.print_task_config
-            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-                return;
-            }
+    // Read NFC filament_detect data for temperature info (optional)
+    nlohmann::json nfc_info;
+    if (json["result"]["status"].contains("filament_detect") &&
+        json["result"]["status"]["filament_detect"].contains("info")) {
+        nfc_info = json["result"]["status"]["filament_detect"]["info"];
+    }
 
-            auto& ptc = json["result"]["status"]["print_task_config"];
+    static const std::string empty_str;
+    static const std::string default_color = "FFFFFFFF";
 
-            // Read parallel arrays from print_task_config
-            auto filament_exist    = read_bool_array_or(ptc, "filament_exist");
-            auto filament_type     = read_string_array_or(ptc, "filament_type");
-            auto filament_sub_type = read_string_array_or(ptc, "filament_sub_type");
-            auto filament_color    = read_string_array_or(ptc, "filament_color_rgba");
-            auto filament_vendor   = read_string_array_or(ptc, "filament_vendor");
+    std::vector<AmsTrayData> trays;
+    trays.reserve(slot_count);
 
-            const int slot_count = static_cast<int>(filament_exist.size());
-            if (slot_count == 0) {
-                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-                return;
-            }
+    for (int i = 0; i < slot_count; ++i) {
+        AmsTrayData tray;
+        tray.slot_index   = i;
+        tray.has_filament = filament_exist[i];
 
-            // Read NFC filament_detect data for temperature info (optional)
-            nlohmann::json nfc_info;
-            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-                nfc_info = json["result"]["status"]["filament_detect"]["info"];
-            }
+        if (tray.has_filament) {
+            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                                                       safe_at(filament_sub_type, i, empty_str));
+            tray.tray_color    = safe_at(filament_color, i, default_color);
 
-            static const std::string empty_str;
-            static const std::string default_color = "FFFFFFFF";
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            // Try to find a matching preset for this filament based on vendor, type and color.
+            // If not found, default to traditional search by type only or generic type mapping.
+            if (bundle) {
+                std::string vendor      = safe_at(filament_vendor, i, empty_str);
+                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
+                                                                                       tray.tray_color);
 
-            std::vector<AmsTrayData> trays;
-            trays.reserve(slot_count);
-
-            for (int i = 0; i < slot_count; ++i) {
-                AmsTrayData tray;
-                tray.slot_index   = i;
-                tray.has_filament = filament_exist[i];
-
-                if (tray.has_filament) {
-                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                    tray.tray_color = safe_at(filament_color, i, default_color);
-
-                    auto* bundle = GUI::wxGetApp().preset_bundle;
-                    // Try to find a matching preset for this filament based on vendor, type and color.
-                    // If not found, default to traditional search by type only or generic type mapping.
-                    if (bundle) {
-                        std::string vendor      = safe_at(filament_vendor, i, empty_str);
-                        std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
-                                                                                               tray.tray_color);
-
-                        if (!filament_id.empty()) {
-                            tray.tray_info_idx = filament_id;
-                            BOOST_LOG_TRIVIAL(warning)
-                                << "Filament sync: Found manufacturer-specific profile for slot " << i << ": " << filament_id;
-                        } else {
-                            tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-                        }
-                    } else {
-                        tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-                    }
-
-                    // Extract NFC temperature data if available
-                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                        auto&       nfc_slot = nfc_info[i];
-                        std::string vendor   = "NONE";
-                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                            vendor = vendor_it->get<std::string>();
-                        }
-                        if (vendor != "NONE" && !vendor.empty()) {
-                            tray.bed_temp    = read_int_or(nfc_slot, "BED_TEMP", 0);
-                            tray.nozzle_temp = read_int_or(nfc_slot, "FIRST_LAYER_TEMP", 0);
-                        }
-                    }
+                if (!filament_id.empty()) {
+                    tray.tray_info_idx = filament_id;
+                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                                               << filament_id;
+                } else {
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
                 }
-
-                trays.emplace_back(std::move(tray));
+            } else {
+                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
             }
 
-            build_ams_payload(1, slot_count - 1, trays);
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception";
+            // Extract NFC temperature data if available
+            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+                auto& nfc_slot = nfc_info[i];
+                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (vendor != "NONE" && !vendor.empty()) {
+                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
+                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
+                }
+            }
         }
-    }).detach();
 
+        trays.emplace_back(std::move(tray));
+    }
+
+    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
-std::string SnapmakerPrinterAgent::get_camera_url() const
-{
-    return get_connection_settings().base_url + "/server/files/camera/monitor.jpg";
-}
-
-FilamentSyncMode SnapmakerPrinterAgent::get_filament_sync_mode() const
-{
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
-
 } // namespace Slic3r

src/slic3r/Utils/SnapmakerPrinterAgent.hpp

@@ -3,8 +3,6 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
-#include <atomic>
-#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -13,25 +11,16 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override { shutdown(); }
+    ~SnapmakerPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    FilamentSyncMode get_filament_sync_mode() const override;
-    int command_start_camera(std::string dev_id) override;
-    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
-    std::string get_camera_url() const override;
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
-
-    void start_camera_monitor();
-    void on_status_loop_tick(const std::string& dev_id) override;
-
-    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

src/slic3r/plugin/PluginFsUtils.hpp

@@ -25,11 +25,19 @@ extern const char* const INSTALL_STATE_FILE;
 // Plugin config and orca.host.ui payloads both cross the boundary as plain JSON-compatible
 // values, so both go through these.
 
-inline pybind11::object json_to_py(const nlohmann::json& j)
+// Maximum nesting depth for JSON <-> Python conversion. A self-referential or pathologically
+// deep value would otherwise recurse until the native C stack overflows, an uncatchable crash;
+// past this bound we raise instead. 200 is far beyond any legitimate plugin config or UI payload.
+inline constexpr int kMaxJsonConversionDepth = 200;
+
+inline pybind11::object json_to_py(const nlohmann::json& j, int depth = 0)
 {
     namespace py = pybind11;
     using json   = nlohmann::json;
 
+    if (depth > kMaxJsonConversionDepth)
+        throw py::value_error("Plugin JSON value nested too deeply");
+
     switch (j.type()) {
     case json::value_t::null:            return py::none();
     case json::value_t::boolean:         return py::bool_(j.get<bool>());
@@ -40,24 +48,27 @@ inline pybind11::object json_to_py(const nlohmann::json& j)
     case json::value_t::array: {
         py::list lst;
         for (const auto& e : j)
-            lst.append(json_to_py(e));
+            lst.append(json_to_py(e, depth + 1));
         return lst;
     }
     case json::value_t::object: {
         py::dict d;
         for (auto it = j.begin(); it != j.end(); ++it)
-            d[py::str(it.key())] = json_to_py(it.value());
+            d[py::str(it.key())] = json_to_py(it.value(), depth + 1);
         return d;
     }
     default: return py::none();
     }
 }
 
-inline nlohmann::json py_to_json(const pybind11::handle& o)
+inline nlohmann::json py_to_json(const pybind11::handle& o, int depth = 0)
 {
     namespace py = pybind11;
     using json   = nlohmann::json;
 
+    if (depth > kMaxJsonConversionDepth)
+        throw py::value_error("Plugin value nested too deeply (possible cycle)");
+
     if (o.is_none())
         return json(nullptr);
     if (py::isinstance<py::bool_>(o)) // bool before int (bool subclasses int in Python)
@@ -73,13 +84,13 @@ inline nlohmann::json py_to_json(const pybind11::handle& o)
     if (py::isinstance<py::dict>(o)) {
         json obj = json::object();
         for (auto item : py::reinterpret_borrow<py::dict>(o))
-            obj[py::str(item.first).cast<std::string>()] = py_to_json(item.second);
+            obj[py::str(item.first).cast<std::string>()] = py_to_json(item.second, depth + 1);
         return obj;
     }
     if (py::isinstance<py::list>(o) || py::isinstance<py::tuple>(o)) {
         json arr = json::array();
         for (auto e : o)
-            arr.push_back(py_to_json(e));
+            arr.push_back(py_to_json(e, depth + 1));
         return arr;
     }
     return py::str(o).cast<std::string>(); // fallback: str()

tests/slic3rutils/CMakeLists.txt

@@ -25,7 +25,6 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_capabilities_in_use.cpp
     test_plugin_status.cpp
     test_printer_agent.cpp
-    test_qidi_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp
@@ -35,6 +34,7 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_sort.cpp
     test_plugin_cloud_metadata.cpp
     test_plugin_audit.cpp
+    test_plugin_json_depth.cpp
     test_shortcuts.cpp
     test_file_url.cpp
     test_user_manager.cpp

tests/slic3rutils/test_plugin_json_depth.cpp

@@ -0,0 +1,73 @@
+#include <catch2/catch_all.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include <slic3r/plugin/PluginFsUtils.hpp>
+#include <slic3r/plugin/PluginManager.hpp>
+#include <slic3r/plugin/PythonInterpreter.hpp>
+
+#include "plugin_test_utils.hpp"
+
+#include <cstdint>
+#include <exception>
+#include <utility>
+
+#include <nlohmann/json.hpp>
+#include <pybind11/embed.h>
+#include <pybind11/gil.h>
+#include <pybind11/pytypes.h>
+
+using namespace Slic3r;
+
+namespace {
+// Brings the embedded interpreter up for one test and tears it down before boost::log does,
+// mirroring the ScopedPluginManager idiom in the other plugin tests.
+struct ScopedPluginManager
+{
+    ScopedDataDir python_data_dir{"plugin-json-depth"};
+    bool          initialized = PluginManager::instance().initialize();
+    ~ScopedPluginManager()
+    {
+        PluginManager::instance().shutdown();
+        PythonInterpreter::instance().shutdown();
+    }
+};
+} // namespace
+
+TEST_CASE("py_to_json raises instead of overflowing on pathologically deep input", "[PluginHost][Python]")
+{
+    ScopedPluginManager manager;
+    REQUIRE(manager.initialized);
+    namespace py = pybind11;
+    py::gil_scoped_acquire gil;
+
+    // [[[ ... 0 ... ]]] nested 300 deep: past the 200 conversion-depth cap, but shallow enough
+    // that the pre-fix code returns without crashing, so a regression fails cleanly rather than
+    // taking the process down. Built in C++ so the test does not depend on Python builtins.
+    py::object deep = py::int_(0);
+    for (int i = 0; i < 300; ++i) {
+        py::list wrapper;
+        wrapper.append(deep);
+        deep = std::move(wrapper);
+    }
+    CHECK_THROWS_AS(py_to_json(deep), std::exception);
+}
+
+TEST_CASE("py_to_json still converts reasonably nested input", "[PluginHost][Python]")
+{
+    ScopedPluginManager manager;
+    REQUIRE(manager.initialized);
+    namespace py = pybind11;
+    py::gil_scoped_acquire gil;
+
+    py::dict d;
+    d["a"] = py::int_(1);
+    py::list inner;
+    inner.append(py::str("x"));
+    inner.append(py::int_(2));
+    d["b"] = inner;
+
+    const nlohmann::json j = py_to_json(d);
+    CHECK(j.at("a").get<std::int64_t>() == 1);
+    CHECK(j.at("b").at(0).get<std::string>() == "x");
+    CHECK(j.at("b").at(1).get<std::int64_t>() == 2);
+}

tests/slic3rutils/test_printer_agent.cpp

@@ -1,29 +1,18 @@
 #include <catch2/catch_all.hpp>
 
-#include <functional>
-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/IPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
-#include "catch2/catch_approx.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
-#include <atomic>
-#include <chrono>
-#include <future>
-#include <slic3r/Utils/bambu_networking.hpp>
 #include <string>
-#include <thread>
 #include <pybind11/cast.h>
-#include <utility>
 
 namespace Slic3r { class ICloudServiceAgent; }
 namespace Slic3r { class IPrinterAgent; }
@@ -31,379 +20,6 @@ namespace Slic3r { class IPrinterAgent; }
 using namespace Slic3r;
 namespace py = pybind11;
 
-namespace {
-
-// Releases a promise on scope exit, so a throwing REQUIRE cannot leave a parked detached
-// thread (and any destructor that joins it) blocked forever.
-class ScopedPromiseRelease
-{
-public:
-    explicit ScopedPromiseRelease(std::shared_ptr<std::promise<void>> p) : m_p(std::move(p)) {}
-    ~ScopedPromiseRelease()
-    {
-        if (m_p) {
-            try {
-                m_p->set_value();
-            } catch (...) {
-                // promise already satisfied
-            }
-        }
-    }
-    ScopedPromiseRelease(const ScopedPromiseRelease&) = delete;
-    ScopedPromiseRelease& operator=(const ScopedPromiseRelease&) = delete;
-
-private:
-    std::shared_ptr<std::promise<void>> m_p;
-};
-
-} // namespace
-
-class MoonrakerParserProbe : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::parse_nozzle_diameter;
-
-    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-};
-
-TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[unit][moonraker]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "settings": {
-                        "extruder": {
-                            "nozzle_diameter": 0.6
-                        }
-                    }
-                }
-            }
-        }
-    })");
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(response) == Catch::Approx(0.6f));
-}
-
-TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[unit][moonraker]")
-{
-    const auto raw_config_response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "config": {
-                        "extruder": {
-                            "nozzle_diameter": "0.8"
-                        }
-                    }
-                }
-            }
-        }
-    })");
-    const auto missing_response = nlohmann::json::object();
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response) == Catch::Approx(0.8f));
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(missing_response) == 0.0f);
-}
-
-// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
-TEST_CASE("unit: default AMS commands report not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-}
-
-TEST_CASE("unit: Moonraker light name matching", "[unit][moonraker]")
-{
-    CHECK(moonraker_is_light_name("caselight"));
-    CHECK(moonraker_is_light_name("LED_STRIP"));
-    CHECK_FALSE(moonraker_is_light_name("beeper"));
-    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
-    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
-}
-
-TEST_CASE("Moonraker webcam selection skips disabled webcams and prefers the first enabled one",
-          "[unit][moonraker]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": { "webcams": [
-            { "name": "disabled", "enabled": false, "stream_url": "http://192.168.1.9:8080/stream" },
-            { "name": "enabled",  "enabled": true,  "stream_url": "http://192.168.1.9:8080/stream" }
-        ]}
-    })");
-
-    MoonrakerWebcamSelection selection;
-    REQUIRE(moonraker_parse_webcam_list(response, "http://192.168.1.9:7125", selection));
-    CHECK(selection.name == "enabled");
-    CHECK(selection.url == "http://192.168.1.9:8080/stream");
-    CHECK(selection.mode == CameraStreamMode::http);
-    CHECK(selection.error.empty());
-}
-
-TEST_CASE("Moonraker webcam selection resolves relative URLs, maps rtsp, and rejects other schemes",
-          "[unit][moonraker]")
-{
-    const auto relative = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "snapshot_url": "/webcam/?action=snapshot" } ] }
-    })");
-    MoonrakerWebcamSelection rel;
-    REQUIRE(moonraker_parse_webcam_list(relative, "http://192.168.1.9:7125", rel));
-    // Relative URLs use the printer web root, without the Moonraker API port.
-    CHECK(rel.url == "http://192.168.1.9/webcam/?action=snapshot");
-    CHECK(rel.mode == CameraStreamMode::http_snapshot);
-
-    const auto rtsp = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "rtsp://192.168.1.9:554/live" } ] }
-    })");
-    MoonrakerWebcamSelection rt;
-    REQUIRE(moonraker_parse_webcam_list(rtsp, "http://192.168.1.9:7125", rt));
-    CHECK(rt.mode == CameraStreamMode::rtsp);
-
-    const auto unsupported = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "weird://host/x" } ] }
-    })");
-    MoonrakerWebcamSelection bad;
-    CHECK_FALSE(moonraker_parse_webcam_list(unsupported, "http://192.168.1.9:7125", bad));
-    CHECK(bad.error == "Unsupported webcam URL");
-}
-
-TEST_CASE("Moonraker webcam selection reports no webcam and malformed structure", "[unit][moonraker]")
-{
-    const auto empty = nlohmann::json::parse(R"({ "result": { "webcams": [] } })");
-    MoonrakerWebcamSelection none;
-    CHECK_FALSE(moonraker_parse_webcam_list(empty, "http://host:7125", none));
-    CHECK(none.error == "No enabled webcam");
-
-    const auto disabled_only = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "disabled", "enabled": false, "stream_url": "http://host/stream" } ] }
-    })");
-    MoonrakerWebcamSelection off;
-    CHECK_FALSE(moonraker_parse_webcam_list(disabled_only, "http://host:7125", off));
-
-    const auto malformed = nlohmann::json::parse(R"({ "result": { "nope": 1 } })");
-    MoonrakerWebcamSelection shape;
-    CHECK_FALSE(moonraker_parse_webcam_list(malformed, "http://host:7125", shape));
-    CHECK(shape.error == "Unexpected JSON structure");
-}
-
-// ===========================================================================
-// UNIT - handle_request's not-supported default.
-// The agent is the only thing that knows what it can translate, so an untranslated
-// command has to say so instead of returning success and letting the UI believe the
-// control worked. Guards the inverse too: the pushing namespace is genuinely
-// satisfied by the websocket status stream, and it re-fires from the keepalive timer
-// roughly once a second, so it must stay a success or it would raise a dialog on a
-// timer. Only branches that touch neither the network nor wx are exercised.
-// ===========================================================================
-TEST_CASE("unit: Moonraker reports untranslated commands as not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-
-    // why: malformed input is a different failure than an untranslated command, and the
-    // default must not swallow it into a misleading not-supported verdict.
-    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
-}
-
-// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override
-// (MoonrakerPrinterAgent's own override is synchronous, but QidiPrinterAgent's override is
-// fire-and-forget: it spawns a detached thread and returns immediately). QidiPrinterAgent is
-// `final`, so this probes the same contract with a controllable double instead.
-TEST_CASE("unit: a fire-and-forget override of fetch_filament_info is not waited on by the caller",
-          "[unit][moonraker]")
-{
-    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
-    {
-    public:
-        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-        // Shared so the detached proxy fetch never touches `this`: a throwing REQUIRE
-        // then cannot leave it dereferencing a destroyed agent.
-        std::shared_ptr<std::atomic<bool>>  invoked{std::make_shared<std::atomic<bool>>(false)};
-        std::shared_ptr<std::promise<void>> release_gate{std::make_shared<std::promise<void>>()};
-        std::shared_ptr<std::promise<void>> done_promise{std::make_shared<std::promise<void>>()};
-
-        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-        {
-            auto invoked_p      = invoked;
-            auto release_gate_p = release_gate;
-            auto done_promise_p = done_promise;
-            std::thread([invoked_p, release_gate_p, done_promise_p]() {
-                invoked_p->store(true);
-                // Block here until the test explicitly releases us, proving the caller
-                // (fetch_filament_info) does not wait for this to run.
-                release_gate_p->get_future().wait();
-                done_promise_p->set_value();
-            }).detach();
-            return true;
-        }
-    };
-
-    auto agent = std::make_shared<RecordingAgent>(std::string{});
-    auto done_future = agent->done_promise->get_future();
-    ScopedPromiseRelease release_gate_guard{agent->release_gate};
-
-    bool immediate_result = agent->fetch_filament_info("test-dev");
-
-    // fetch_filament_info must return before its background work completes — prove
-    // it by confirming the background call is still blocked on the gate right now.
-    REQUIRE(immediate_result == true);
-    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
-
-    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
-    agent->release_gate->set_value();
-    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
-    REQUIRE(agent->invoked->load() == true);
-}
-
-namespace {
-
-// Globals so a parked proxy fetch thread never dereferences a freed agent.
-std::atomic<int>  g_deferred_fetch_running{0};
-std::atomic<bool> g_deferred_destroy_returned{false};
-
-// Releases the given gates, then joins on scope exit: so a throwing REQUIRE cannot leave
-// the thread blocked (deadlocking the join) or let it std::terminate.
-class ScopedJoiner
-{
-public:
-    ScopedJoiner(std::thread& t, std::shared_ptr<std::promise<void>> gate1, std::shared_ptr<std::promise<void>> gate2)
-        : m_thread(t), m_gates{std::move(gate1), std::move(gate2)}
-    {}
-    ~ScopedJoiner()
-    {
-        for (auto& gate : m_gates) {
-            if (gate) {
-                try {
-                    gate->set_value();
-                } catch (...) {
-                    // promise already satisfied
-                }
-            }
-        }
-        if (m_thread.joinable()) m_thread.join();
-    }
-    ScopedJoiner(const ScopedJoiner&) = delete;
-    ScopedJoiner& operator=(const ScopedJoiner&) = delete;
-
-private:
-    std::thread&                        m_thread;
-    std::shared_ptr<std::promise<void>> m_gates[2];
-};
-
-// A fetch that parks before touching the in-flight counter, so teardown's wait can
-// observe zero first.
-class DeferredFetchAgent : public MoonrakerPrinterAgent
-{
-public:
-    explicit DeferredFetchAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-    // Shared so a parked proxy fetch can never outlive the stack that owns it.
-    std::shared_ptr<std::promise<void>> entered{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_fetch{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_finish{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> running{std::make_shared<std::promise<void>>()};
-
-    // Runs the callable on the command worker, which teardown joins.
-    void post(std::function<void()> fn) { enqueue_command(std::move(fn)); }
-
-    bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-    {
-        // Resumes after ~DeferredFetchAgent destroyed these members; snapshot up front.
-        auto entered_p      = entered;
-        auto allow_fetch_p  = allow_fetch;
-        auto allow_finish_p = allow_finish;
-        auto running_p      = running;
-
-        entered_p->set_value();
-        allow_fetch_p->get_future().wait();
-
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-        std::thread([this, finish = std::move(allow_finish_p), running = std::move(running_p)] {
-            struct InFlightGuard
-            {
-                MoonrakerPrinterAgent& owner;
-                ~InFlightGuard() { owner.release_fetch_slot(); }
-            } guard{*this};
-
-            g_deferred_fetch_running.fetch_add(1, std::memory_order_relaxed);
-            running->set_value();
-            finish->get_future().wait();
-            g_deferred_fetch_running.fetch_sub(1, std::memory_order_relaxed);
-        }).detach();
-        return true;
-    }
-};
-
-} // namespace
-
-// REGRESSION - teardown must not return while a fetch it started is in flight.
-// The command worker parks a fetch before it reserves the in-flight slot, forcing
-// the "wait already observed zero" interleaving deterministically.
-TEST_CASE("an agent's destruction waits for a fetch started by its worker during teardown",
-          "[unit][moonraker][Regression]")
-{
-    g_deferred_fetch_running.store(0);
-    g_deferred_destroy_returned.store(false);
-
-    auto agent        = std::make_shared<DeferredFetchAgent>(std::string{});
-    auto entered      = agent->entered;
-    auto allow_fetch  = agent->allow_fetch;
-    auto allow_finish = agent->allow_finish;
-    auto running      = agent->running;
-
-    // Safety net for the pre-destroyer failure paths: release both gates before the
-    // agent is destroyed (declared after it, so destroyed before it).
-    ScopedPromiseRelease release_finish{allow_finish};
-    ScopedPromiseRelease release_fetch{allow_fetch};
-
-    // Park a fetch inside the command worker while the agent is still complete.
-    agent->post([ptr = agent.get()] { ptr->fetch_filament_info("dev", FilamentSyncMode::pull); });
-    REQUIRE(entered->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-
-    // Destroy on another thread so this one can drive the parked fetch.
-    std::thread destroyer([owned = std::move(agent)]() mutable {
-        owned.reset();
-        g_deferred_destroy_returned.store(true);
-    });
-    // Releases both gates before joining, so a failing REQUIRE cannot deadlock the join.
-    ScopedJoiner join_destroyer{destroyer, allow_fetch, allow_finish};
-
-    // Let the worker reserve the in-flight slot and spawn its fetch, then wait until it
-    // is genuinely parked (no polling).
-    allow_fetch->set_value();
-    REQUIRE(running->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-    REQUIRE(g_deferred_fetch_running.load() == 1);
-
-    // A correct teardown cannot return while the fetch is parked; give a buggy one time.
-    for (int i = 0; i < 200 && !g_deferred_destroy_returned.load(); ++i)
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-    if (g_deferred_destroy_returned.load()) {
-        // Bug: teardown returned with a fetch still running. Don't release allow_finish.
-        CHECK(g_deferred_fetch_running.load() == 0);
-        return;
-    }
-
-    // Fixed order: destruction is still blocked on the in-flight fetch.
-    allow_finish->set_value();
-    destroyer.join();
-    CHECK(g_deferred_destroy_returned.load());
-    CHECK(g_deferred_fetch_running.load() == 0);
-}
-
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in

tests/slic3rutils/test_qidi_printer_agent.cpp

@@ -1,134 +0,0 @@
-#include "catch2/catch_test_macros.hpp"
-#include "catch2/matchers/catch_matchers.hpp"
-#include "catch2/matchers/catch_matchers_string.hpp"
-#include <catch2/catch_all.hpp>
-
-#include <nlohmann/json.hpp>
-
-#include <slic3r/Utils/QidiPrinterAgent.hpp>
-
-#include <string>
-
-using namespace Slic3r;
-
-TEST_CASE("Qidi slot response rejects null variables without throwing", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": null
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("variables"));
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("object"));
-}
-
-TEST_CASE("Qidi slot response rejects missing and non-object fields without throwing", "[QidiPrinterAgent]")
-{
-    std::string response;
-
-    SECTION("missing result")
-    {
-        response = R"({})";
-    }
-
-    SECTION("non-object result")
-    {
-        response = R"({"result":null})";
-    }
-
-    SECTION("missing status")
-    {
-        response = R"({"result":{}})";
-    }
-
-    SECTION("non-object status")
-    {
-        response = R"({"result":{"status":null}})";
-    }
-
-    SECTION("missing save_variables")
-    {
-        response = R"({"result":{"status":{}}})";
-    }
-
-    SECTION("non-object save_variables")
-    {
-        response = R"({"result":{"status":{"save_variables":null}}})";
-    }
-
-    SECTION("missing variables")
-    {
-        response = R"({"result":{"status":{"save_variables":{}}}})";
-    }
-
-    SECTION("scalar")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":42}}}})";
-    }
-
-    SECTION("array")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":[]}}}})";
-    }
-
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-}
-
-TEST_CASE("Qidi slot response exposes valid status and variables", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": {
-                        "box_count": 2,
-                        "color_slot0": 3
-                    }
-                },
-                "box_stepper slot0": {
-                    "runout_button": 0
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = false;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    REQUIRE(parsed);
-    CHECK(status.is_object());
-    CHECK(variables.is_object());
-    CHECK(variables.at("box_count") == 2);
-    CHECK(status.contains("box_stepper slot0"));
-}
-
-TEST_CASE("Qidi slot response rejects invalid JSON", "[QidiPrinterAgent]")
-{
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response("{not json", status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK(error == "Invalid JSON response");
-}