Merge branch 'main' into fix/missing-local-plugins

src/libslic3r/Preset.cpp

@@ -3504,7 +3504,7 @@ inline t_config_option_keys deep_diff(const ConfigBase &config_this, const Confi
         if (this_opt != nullptr && other_opt != nullptr && *this_opt != *other_opt)
         {
             //BBS: add bed_exclude_area
-            if (opt_key == "printable_area" || opt_key == "bed_exclude_area" || opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "thumbnails" ||  opt_key == "wrapping_exclude_area" || opt_key == "slicing_pipeline_plugin") {
+            if (opt_key == "printable_area" || opt_key == "bed_exclude_area" || opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "thumbnails" ||  opt_key == "wrapping_exclude_area") {
                 // Scalar variable, or a vector variable, which is independent from number of extruders,
                 // thus the vector is presented to the user as a single input.
                 diff.emplace_back(opt_key);

src/slic3r/GUI/PluginWebDialog.cpp

@@ -48,14 +48,13 @@ std::string plugin_defaults_user_script()
     return WebViewHostDialog::document_start_injector(css, "orca-plugin-defaults", "beforeend");
 }
 
-// Injected into the top-level page at document start (before the plugin's own
-// scripts). Defines window.orca as the only host surface the page may use. It
-// references window.wx lazily (at call time) so it never races the backend's
-// deferred registration of the "wx" message handler. Guarded against
-// double-injection so it is harmless if also prepended.
+// Injected into every page at document start (before the plugin's own scripts).
+// Defines window.orca as the only host surface the page may use. It references
+// window.wx lazily (at call time) so it never races the backend's deferred
+// registration of the "wx" message handler. Guarded against double-injection so
+// it is harmless if also prepended.
 constexpr char ORCA_BRIDGE_JS[] = R"JS(
 (function () {
-  if (window.top !== window.self) return;
   if (window.orca) return;
   var handlers = [];
   function send(kind, data) {

src/slic3r/GUI/PluginsDialog.cpp

@@ -300,12 +300,7 @@ PluginAvailableActions evaluate_action_policy(const PluginDialogItem& item)
 
     add_action("open_folder", "Show in folder", has_local);
 
-    if (is_cloud) {
-        add_action("reinstall_plugin", "Reinstall");
-    } else {
-        add_action("reload_plugin", "Reload");
-        add_action("clear_cache_reload_plugin", "Delete cache and reload");
-    }
+    add_action("reinstall_plugin", "Reinstall");
 
     return available_actions;
 }
@@ -590,7 +585,35 @@ bool PluginsDialog::get_descriptor(const std::string& plugin_key, PluginDescript
 
 void PluginsDialog::refresh_plugin_metadata_async(const wxString& title, const wxString& message, bool fetch_cloud)
 {
-    run_with_dialog([fetch_cloud]() { refresh_plugin_metadata_blocking(fetch_cloud); }, [this]() { send_plugins(); }, title, message);
+    run_with_dialog([fetch_cloud]() { refresh_plugin_metadata_blocking(fetch_cloud); }, [this]() {
+        prompt_for_missing_plugins();
+        send_plugins();
+    }, title, message);
+}
+
+void PluginsDialog::prompt_for_missing_plugins()
+{
+    PluginManager& manager = PluginManager::instance();
+    const std::vector<PluginDescriptor> missing = manager.get_missing_plugin_descriptors();
+    if (missing.empty())
+        return;
+
+    wxString names;
+    std::vector<std::string> keys;
+    keys.reserve(missing.size());
+    for (const PluginDescriptor& plugin : missing) {
+        keys.push_back(plugin.plugin_key);
+        names += "\n- ";
+        names += plugin_display_name(plugin.plugin_key);
+    }
+
+    const int result = wxMessageBox(
+        wxString::Format(_L("The following installed plugins were not found on disk:\n%s\n\nRemove them from OrcaSlicer?"), names),
+        _L("Missing Plugins"), wxYES_NO | wxNO_DEFAULT | wxICON_WARNING, this);
+    restore_z_order();
+
+    if (result == wxYES)
+        manager.remove_missing_plugins(keys);
 }
 
 void PluginsDialog::refresh_plugins()
@@ -744,13 +767,11 @@ void PluginsDialog::handle_plugin_menu_action(const std::string& plugin_key, con
         unsubscribe_cloud_plugin(row_data);
     } else if (action == "delete_mine_plugin") {
         delete_mine_local_and_cloud_plugin(plugin_key);
-    } else if (action == "reload_plugin") {
-        reload_local_plugin(plugin_key, /*clear_cache=*/false);
-    } else if (action == "clear_cache_reload_plugin") {
-        reload_local_plugin(plugin_key, /*clear_cache=*/true);
     } else if (action == "reinstall_plugin") {
         if (row_data.is_cloud_plugin())
             reinstall_cloud_plugin(row_data);
+        else
+            reinstall_local_plugin(plugin_key);
     }
 }
 
@@ -1130,7 +1151,7 @@ void PluginsDialog::unsubscribe_cloud_plugin(const PluginDescriptor& plugin)
         _L("Unsubscribing plugin"), _L("Deleting local files and unsubscribing plugin..."));
 }
 
-void PluginsDialog::reload_local_plugin(const std::string& plugin_key, bool clear_cache)
+void PluginsDialog::reinstall_local_plugin(const std::string& plugin_key)
 {
     if (plugin_key.empty())
         return;
@@ -1139,34 +1160,11 @@ void PluginsDialog::reload_local_plugin(const std::string& plugin_key, bool clea
     std::pair<bool, std::string> reload_result{false, ""};
     try {
         reload_result = run_with_dialog_wait(
-            [plugin_key, was_loaded, clear_cache]() -> std::pair<bool, std::string> {
+            [plugin_key, was_loaded]() -> std::pair<bool, std::string> {
                 PluginManager& manager = PluginManager::instance();
-
-                boost::filesystem::path cache_dir;
-                if (clear_cache) {
-                    PluginDescriptor descriptor;
-                    if (!manager.try_get_plugin_descriptor(plugin_key, descriptor))
-                        return {false, "Plugin not found."};
-
-                    boost::filesystem::path resolved_root;
-                    std::string                  resolve_error;
-                    if (!resolve_allowed_plugin_root(descriptor, {get_orca_plugins_dir()},
-                                                     "Refusing to clear a plugin cache outside the local plugin directory.",
-                                                     resolved_root, resolve_error))
-                        return {false, resolve_error};
-                    cache_dir = resolved_root / "__whl_extracted__";
-                }
-
                 if (!manager.unload_plugin(plugin_key))
                     return {false, "Failed to unload plugin."};
 
-                if (clear_cache) {
-                    boost::system::error_code ec;
-                    boost::filesystem::remove_all(cache_dir, ec);
-                    if (ec)
-                        return {false, "Failed to clear plugin cache: " + ec.message()};
-                }
-
                 manager.load_plugin(plugin_key, false);
                 std::string error;
                 if (!manager.wait_for_plugin_load(plugin_key, std::chrono::minutes(5), error) || !manager.is_plugin_loaded(plugin_key))

src/slic3r/GUI/PluginsDialog.hpp

@@ -68,6 +68,7 @@ private:
     bool get_descriptor(const std::string& plugin_key, Slic3r::PluginDescriptor& descriptor) const;
 
     void refresh_plugin_metadata_async(const wxString& title, const wxString& message, bool fetch_cloud);
+    void prompt_for_missing_plugins();
     void refresh_plugins();
     void toggle_plugin(const std::string& plugin_key, bool enabled);
     void toggle_plugin_capability(const std::string& plugin_key, PluginCapabilityType type, const std::string& capability_name, bool enabled);
@@ -96,7 +97,7 @@ private:
     void open_plugin_folder(const Slic3r::PluginDescriptor& plugin);
     void delete_local_plugin(const Slic3r::PluginDescriptor& plugin);
     void unsubscribe_cloud_plugin(const Slic3r::PluginDescriptor& plugin);
-    void reload_local_plugin(const std::string& plugin_key, bool clear_cache);
+    void reinstall_local_plugin(const std::string& plugin_key);
     void reinstall_cloud_plugin(const Slic3r::PluginDescriptor& plugin);
     void delete_mine_local_and_cloud_plugin(const std::string& plugin_key);
 

src/slic3r/GUI/Tab.cpp

@@ -34,7 +34,6 @@
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
 #include "slic3r/Utils/PresetUpdater.hpp"
-#include "slic3r/plugin/PluginConfig.hpp"
 #include "Plater.hpp"
 #include "MainFrame.hpp"
 #include "format.hpp"
@@ -1796,19 +1795,9 @@ void Tab::on_value_change(const std::string& opt_key, const boost::any& value)
 
     // Keep this preset's "plugins" manifest in sync when a plugin picker changes, so full_config() and
     // save_to_json() always find resolved "name;uuid;capability" references and rebuild it nowhere else.
-    // Also drop any plugin_config_overrides entries for a capability the change just stopped
-    // referencing (e.g. a plugin removed from slicing_pipeline_plugin), so a saved preset never
-    // carries configuration for a capability it no longer names. The Configure button is a separate
-    // field holding its own cached copy of that value, so it needs to be told explicitly, or it
-    // keeps showing the stale count until something else happens to refresh it.
     if (const ConfigOptionDef* opt_def = m_config->def()->get(opt_key);
-        opt_def && opt_def->is_plugin_backed()) {
+        opt_def && opt_def->is_plugin_backed())
         m_config->update_plugin_manifest();
-        if (prune_stale_plugin_overrides(*m_config)) {
-            if (Field* overrides_field = get_field(PLUGIN_OVERRIDES_OPTION_KEY))
-                overrides_field->set_value(boost::any(m_config->opt_string(PLUGIN_OVERRIDES_OPTION_KEY)), false);
-        }
-    }
 
     if (opt_key == "gcode_flavor" && m_type == Preset::TYPE_PRINTER) {
         if (auto printer_tab = dynamic_cast<TabPrinter*>(this))

src/slic3r/GUI/Widgets/WebViewHostDialog.cpp

@@ -96,9 +96,6 @@ std::string WebViewHostDialog::document_start_injector(const std::string& markup
     const std::string literal = nlohmann::json(markup).dump();
     std::string       s;
     s += "(function(){";
-    // wxWebView's AddUserScript runs in child frames too (including cross-origin
-    // frames on WebView2). Host theme state belongs only to the top-level page.
-    s += "if(window.top!==window.self)return;";
     s += prelude;
     s += "var css=" + literal + ";";
     s += "function inject(){";

src/slic3r/plugin/PluginConfig.cpp

@@ -5,7 +5,6 @@
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/fstream.hpp>
 
-#include <libslic3r/Config.hpp>
 #include <libslic3r/PresetBundle.hpp>
 #include <libslic3r/PrintConfig.hpp>
 #include <slic3r/GUI/GUI.hpp>
@@ -165,20 +164,6 @@ bool CapabilityConfigDocument::erase(const PluginCapabilityId& id)
     return erased;
 }
 
-bool CapabilityConfigDocument::prune_unreferenced(const std::set<std::pair<PluginCapabilityType, std::string>>& referenced)
-{
-    bool changed = false;
-    for (auto it = m_entries.begin(); it != m_entries.end();) {
-        if (referenced.count({it->first.type, it->first.name}) != 0) {
-            ++it;
-        } else {
-            it      = m_entries.erase(it);
-            changed = true;
-        }
-    }
-    return changed;
-}
-
 bool CapabilityConfigDocument::empty() const
 {
     return m_entries.empty() && m_opaque_entries.empty();
@@ -357,50 +342,6 @@ std::string serialize_plugin_overrides(const CapabilityConfigDocument& document)
     return document.empty() ? std::string() : document.serialize_entries().dump();
 }
 
-bool prune_stale_plugin_overrides(DynamicConfig& config)
-{
-    const auto* overrides_opt = dynamic_cast<const ConfigOptionString*>(config.option(PLUGIN_OVERRIDES_OPTION_KEY));
-    if (overrides_opt == nullptr || overrides_opt->value.empty())
-        return false;
-
-    CapabilityConfigDocument overrides;
-    std::string              error;
-    if (!parse_plugin_overrides(overrides_opt->value, overrides, error)) {
-        // Malformed text is not ours to fix up here: leave it untouched rather than risk
-        // discarding data the user might still be able to recover.
-        BOOST_LOG_TRIVIAL(error) << "prune_stale_plugin_overrides: " << error;
-        return false;
-    }
-
-    // Capability names currently referenced by a plugin-backed option's value(s) — e.g.
-    // slicing_pipeline_plugin's ConfigOptionStrings entries name SlicingPipeline capabilities
-    // directly, the same raw values save_plugin_collection() resolves into the "plugins" manifest.
-    std::set<std::pair<PluginCapabilityType, std::string>> referenced;
-    const ConfigDef* def = config.def();
-    for (const std::string& opt_key : config.keys()) {
-        const ConfigOptionDef* opt_def = def != nullptr ? def->get(opt_key) : nullptr;
-        if (opt_def == nullptr || !opt_def->is_plugin_backed())
-            continue;
-
-        const ConfigOption*        opt  = config.option(opt_key);
-        const PluginCapabilityType type = plugin_capability_type_from_string(opt_def->plugin_type);
-        if (const auto* string_opt = dynamic_cast<const ConfigOptionString*>(opt)) {
-            if (!string_opt->value.empty())
-                referenced.emplace(type, string_opt->value);
-        } else if (const auto* vector_opt = dynamic_cast<const ConfigOptionVectorBase*>(opt)) {
-            for (const std::string& value : vector_opt->vserialize())
-                if (!value.empty())
-                    referenced.emplace(type, value);
-        }
-    }
-
-    if (!overrides.prune_unreferenced(referenced))
-        return false;
-
-    config.set_key_value(PLUGIN_OVERRIDES_OPTION_KEY, new ConfigOptionString(serialize_plugin_overrides(overrides)));
-    return true;
-}
-
 EffectiveCapabilityConfig PresetPluginConfigService::get_effective_config(const CapabilityConfigDocument&   overrides,
                                                                          const PluginCapabilityId& id) const
 {

src/slic3r/plugin/PluginConfig.hpp

@@ -8,9 +8,7 @@
 #include <map>
 #include <mutex>
 #include <optional>
-#include <set>
 #include <string>
-#include <utility>
 #include <vector>
 
 #define PLUGIN_CONFIG_DIR "config.json"
@@ -18,7 +16,6 @@
 namespace Slic3r {
 
 class Preset;
-class DynamicConfig;
 struct CapabilityConfigEntry
 {
     PluginCapabilityId id;
@@ -38,9 +35,6 @@ public:
     bool                                 contains(const PluginCapabilityId& id) const;
     bool                                 upsert(CapabilityConfigEntry entry);
     bool                                 erase(const PluginCapabilityId& id);
-    // Drops every entry whose (type, name) is not in `referenced`, e.g. capabilities a preset's
-    // plugin-backed options no longer name. Returns true if anything was removed.
-    bool                                 prune_unreferenced(const std::set<std::pair<PluginCapabilityType, std::string>>& referenced);
     bool                                 empty() const;
     nlohmann::json                       serialize_entries() const;
     nlohmann::json                       root_json() const;
@@ -56,14 +50,6 @@ std::string plugin_overrides_of(const Preset& preset);
 bool parse_plugin_overrides(const std::string& raw, CapabilityConfigDocument& document, std::string& error);
 std::string serialize_plugin_overrides(const CapabilityConfigDocument& document);
 
-// Drops plugin_config_overrides entries for capabilities no longer named by any plugin-backed
-// option's current value in `config` (e.g. slicing_pipeline_plugin cleared or switched to a
-// different capability), and writes the result back if anything changed. Called wherever a
-// plugin-backed option's value changes, so a saved preset never carries configuration for a
-// capability it no longer references. Returns true if `config` was modified, so a caller holding a
-// GUI field over PLUGIN_OVERRIDES_OPTION_KEY knows it must refresh that field's displayed value.
-bool prune_stale_plugin_overrides(DynamicConfig& config);
-
 struct EffectiveCapabilityConfig
 {
     PluginCapabilityId id;

src/slic3r/plugin/PluginDescriptor.hpp

@@ -54,7 +54,7 @@ struct PluginDescriptor
     std::string description;                            // Plugin description
     std::string author;                                 // Plugin author from manifest, if available
     std::string version;                                // Selected plugin version
-    std::string latest_version;                         // Authoritative latest available cloud version.
+    std::string latest_version;                         // Latest available cloud version fallback when changelog is unavailable.
     std::string installed_version;                       // Locally installed package version. Preserved across cloud merges, which overwrite `version` with the latest cloud version. Empty when not installed.
     std::vector<std::string> display_types;             // Display-only "compatibility" labels (cloud: raw service labels; local: from real capabilities). Never used for dispatch.
     std::string plugin_root;                            // Installed plugin directory, even when entry_path is invalid or ambiguous.
@@ -113,6 +113,10 @@ struct PluginDescriptor
     bool is_unauthorized() const { return get_update_status() == PluginUpdateStatus::Unauthorized; }
     std::string latest_available_version() const
     {
+        for (const PluginChangelog& entry : changelog) {
+            if (!entry.version.empty())
+                return entry.version;
+        }
         if (!latest_version.empty())
             return latest_version;
         return version;

src/slic3r/plugin/PluginFsUtils.cpp

@@ -120,8 +120,7 @@ bool delete_plugin_root(const boost::filesystem::path& resolved_root, const std:
     }
 
     if (removed_count == 0) {
-        error = "Plugin folder was not found: " + resolved_root.string();
-        return false;
+        return true;
     }
 
     BOOST_LOG_TRIVIAL(info) << "Deleted plugin: " << plugin_id << " from " << resolved_root.string();

src/slic3r/plugin/PluginManager.cpp

@@ -310,6 +310,7 @@ void PluginManager::merge_discovered_plugins(std::vector<PluginDescriptor> disco
             }
 
             seen.push_back(descriptor.plugin_key);
+            m_missing_plugin_keys.erase(descriptor.plugin_key);
 
             Plugin* existing = find_plugin_locked(descriptor.plugin_key);
             if (existing == nullptr) {
@@ -328,12 +329,47 @@ void PluginManager::merge_discovered_plugins(std::vector<PluginDescriptor> disco
             return;
     }
 
-    // Unloading may call Python and lifecycle subscribers may re-enter the manager, so never do it
-    // while holding m_mutex. unload_and_erase_if() retries until no matching entry is loaded at the
-    // moment of erase, in case another caller starts a load between the initial snapshot and the
-    // teardown.
-    unload_and_erase_if(
-        [&seen](const Plugin& plugin) { return std::find(seen.begin(), seen.end(), plugin.descriptor.plugin_key) == seen.end(); });
+    // A package can be temporarily absent while an external side-loader replaces it. Keep the
+    // descriptor and its persisted enable state until the user explicitly removes the missing
+    // entry, or a later scan rediscovers it. In particular, do not unload here: the unload callback
+    // would turn a transient filesystem gap into enabled=false in the sidecar.
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        for (const Plugin& plugin : m_plugins) {
+            if (plugin.descriptor.has_local_package() &&
+                std::find(seen.begin(), seen.end(), plugin.descriptor.plugin_key) == seen.end())
+                m_missing_plugin_keys.insert(plugin.descriptor.plugin_key);
+        }
+    }
+}
+
+std::vector<PluginDescriptor> PluginManager::get_missing_plugin_descriptors() const
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+
+    std::vector<PluginDescriptor> result;
+    result.reserve(m_missing_plugin_keys.size());
+    for (const Plugin& plugin : m_plugins)
+        if (m_missing_plugin_keys.count(plugin.descriptor.plugin_key) != 0)
+            result.push_back(plugin.descriptor);
+    return result;
+}
+
+void PluginManager::remove_missing_plugins(const std::vector<std::string>& plugin_keys)
+{
+    const std::unordered_set<std::string> requested(plugin_keys.begin(), plugin_keys.end());
+
+    // The predicate is evaluated only while m_mutex is held by unload_and_erase_if(). Checking the
+    // current missing set here prevents a package that reappeared between the dialog and removal
+    // from being erased.
+    unload_and_erase_if([this, &requested](const Plugin& plugin) {
+        return requested.count(plugin.descriptor.plugin_key) != 0 &&
+               m_missing_plugin_keys.count(plugin.descriptor.plugin_key) != 0;
+    });
+
+    std::lock_guard<std::mutex> lock(m_mutex);
+    for (const std::string& plugin_key : requested)
+        m_missing_plugin_keys.erase(plugin_key);
 }
 
 void PluginManager::unload_and_erase_if(const std::function<bool(const Plugin&)>& should_remove,

src/slic3r/plugin/PluginManager.hpp

@@ -132,6 +132,11 @@ public:
     bool try_get_plugin_descriptor(const std::string& plugin_key, PluginDescriptor& out) const;
     // Same, but only for packages that are loadable (i.e. not an invalid package).
     bool try_get_valid_plugin_descriptor(const std::string& plugin_key, PluginDescriptor& out) const;
+    // Packages that were present in the previous discovery pass but were not found on disk in the
+    // latest rescan. They are retained until the user explicitly removes them or a later scan finds
+    // them again.
+    std::vector<PluginDescriptor> get_missing_plugin_descriptors() const;
+    void remove_missing_plugins(const std::vector<std::string>& plugin_keys);
     // Packages whose .install_state.json marks them for auto-load.
     std::vector<std::string> get_enabled_plugin_keys() const;
     // The package owning a loaded capability, for the by-name dispatch path.
@@ -264,6 +269,7 @@ private:
 
     // Every discovered plugin, loaded or not. module == nullptr => not loaded.
     std::vector<Plugin> m_plugins;
+    std::unordered_set<std::string> m_missing_plugin_keys;
 
     std::unordered_set<std::string> m_load_in_progress;
     // Keys whose in-flight load has been cancelled. Cancellation does NOT remove the key from

tests/slic3rutils/test_plugin_cloud_metadata.cpp

@@ -52,29 +52,6 @@ print('ok')
 
 } // namespace
 
-TEST_CASE("plugin latest version uses the authoritative catalog field", "[PluginDescriptor]")
-{
-    PluginDescriptor descriptor;
-    descriptor.version        = "1.3.0";
-    descriptor.latest_version = "1.3.0";
-    PluginChangelog changelog;
-    changelog.version = "1.2.0";
-    descriptor.changelog.push_back(changelog);
-
-    CHECK(descriptor.latest_available_version() == "1.3.0");
-}
-
-TEST_CASE("plugin latest version falls back to the descriptor version", "[PluginDescriptor]")
-{
-    PluginDescriptor descriptor;
-    descriptor.version = "1.1.0";
-    PluginChangelog changelog;
-    changelog.version = "1.0.0";
-    descriptor.changelog.push_back(changelog);
-
-    CHECK(descriptor.latest_available_version() == "1.1.0");
-}
-
 // Regression: update_cloud_metadata() replaces a matched entry's descriptor wholesale with the
 // cloud catalog record (`entry = cloud_entry`). Configuration used to ride on the descriptor, so
 // that overwrite silently wiped it and plugins fell back to their built-in defaults (found via