Merge branch 'main' into feat/plugin-storage-api

src/slic3r/plugin/CloudPluginService.cpp

@@ -113,39 +113,6 @@ bool CloudPluginService::request_cloud_unsubscribe(const PluginDescriptor& plugi
     return true;
 }
 
-bool CloudPluginService::request_cloud_delete(const PluginDescriptor& plugin, std::string& error) const
-{
-    if (!m_orca_agent) {
-        error = "No cloud agent.";
-        return false;
-    }
-
-    if (!plugin.is_cloud_plugin()) {
-        error = "Only cloud plugins can be deleted.";
-        return false;
-    }
-
-    const std::string cloud_uuid = plugin.cloud_uuid();
-    if (cloud_uuid.empty()) {
-        error = "Cloud plugin key is missing UUID.";
-        return false;
-    }
-
-    if (!plugin.cloud.has_value() || !plugin.cloud->is_mine) {
-        error = "Only your own plugins can be deleted from the cloud.";
-        return false;
-    }
-
-    int result = m_orca_agent->delete_my_plugin(cloud_uuid);
-
-    if (result != 0) {
-        error = "Failed to delete plugin from cloud, see logs for more info.";
-        return false;
-    }
-
-    return true;
-}
-
 bool CloudPluginService::download_cloud_plugin(PluginDescriptor& entry,
                                                const std::string& requested_version,
                                                CloudPluginDownload& download,

src/slic3r/plugin/CloudPluginService.hpp

@@ -29,7 +29,6 @@ public:
                                       std::vector<std::string>& unauthorized) const;
     bool request_cloud_subscribe(const std::string& plugin_uuid, std::string& error) const;
     bool request_cloud_unsubscribe(const PluginDescriptor& plugin, std::string& error) const;
-    bool request_cloud_delete(const PluginDescriptor& plugin, std::string& error) const;
     bool download_cloud_plugin(PluginDescriptor& entry,
                                const std::string& requested_version,
                                CloudPluginDownload& download,

src/slic3r/plugin/PluginConfig.cpp

@@ -324,12 +324,6 @@ bool PluginConfig::dirty() const
     return m_dirty;
 }
 
-std::string plugin_overrides_of(const Preset& preset)
-{
-    const auto* opt = dynamic_cast<const ConfigOptionString*>(preset.config.option(PLUGIN_OVERRIDES_OPTION_KEY));
-    return opt == nullptr ? std::string() : opt->value;
-}
-
 bool parse_plugin_overrides(const std::string& raw, CapabilityConfigDocument& document, std::string& error)
 {
     document = CapabilityConfigDocument();
@@ -357,9 +351,9 @@ std::string serialize_plugin_overrides(const CapabilityConfigDocument& document)
     return document.empty() ? std::string() : document.serialize_entries().dump();
 }
 
-bool prune_stale_plugin_overrides(DynamicConfig& config)
+bool prune_stale_plugin_overrides(DynamicConfig& config, const std::string& overrides_key)
 {
-    const auto* overrides_opt = dynamic_cast<const ConfigOptionString*>(config.option(PLUGIN_OVERRIDES_OPTION_KEY));
+    const auto* overrides_opt = dynamic_cast<const ConfigOptionString*>(config.option(overrides_key));
     if (overrides_opt == nullptr || overrides_opt->value.empty())
         return false;
 
@@ -397,7 +391,7 @@ bool prune_stale_plugin_overrides(DynamicConfig& config)
     if (!overrides.prune_unreferenced(referenced))
         return false;
 
-    config.set_key_value(PLUGIN_OVERRIDES_OPTION_KEY, new ConfigOptionString(serialize_plugin_overrides(overrides)));
+    config.set_key_value(overrides_key, new ConfigOptionString(serialize_plugin_overrides(overrides)));
     return true;
 }
 
@@ -470,27 +464,29 @@ EffectiveCapabilityConfig active_capability_config(const PluginCapabilityId& id)
 
     if (bundle != nullptr) {
         const std::string type_key = plugin_capability_type_to_string(id.type);
+        // The edited preset of each type that can hold plugin-backed options, keyed by its option list.
+        const std::pair<const std::vector<std::string>*, const Preset*> scopes[] = {
+            {&Preset::print_options(),    &bundle->prints.get_edited_preset()},
+            {&Preset::printer_options(),  &bundle->printers.get_edited_preset()},
+            {&Preset::filament_options(), &bundle->filaments.get_edited_preset()},
+        };
         for (const auto& [key, def] : print_config_def.options) {
             if (def.plugin_type != type_key)
                 continue;
-
-            const auto& print_options = Preset::print_options();
-            if (std::find(print_options.begin(), print_options.end(), key) != print_options.end()) {
-                preset = &bundle->prints.get_edited_preset();
+            for (const auto& [options, edited] : scopes)
+                if (contains(*options, key)) {
+                    preset = edited;
+                    break;
+                }
+            if (preset != nullptr)
                 break;
-            }
-
-            const auto& printer_options = Preset::printer_options();
-            if (std::find(printer_options.begin(), printer_options.end(), key) != printer_options.end()) {
-                preset = &bundle->printers.get_edited_preset();
-                break;
-            }
         }
     }
 
     if (preset != nullptr) {
+        const auto* stored = dynamic_cast<const ConfigOptionString*>(preset->config.option(Preset::plugin_overrides_key(preset->type)));
         std::string error;
-        if (!parse_plugin_overrides(plugin_overrides_of(*preset), overrides, error)) {
+        if (!parse_plugin_overrides(stored == nullptr ? std::string() : stored->value, overrides, error)) {
             // Text we cannot read is not an override: log it and resolve against the base config.
             BOOST_LOG_TRIVIAL(error) << "Preset \"" << preset->name << "\": " << error;
             overrides = CapabilityConfigDocument();

src/slic3r/plugin/PluginConfig.hpp

@@ -17,7 +17,6 @@
 
 namespace Slic3r {
 
-class Preset;
 class DynamicConfig;
 struct CapabilityConfigEntry
 {
@@ -50,19 +49,15 @@ private:
     std::vector<nlohmann::json>                  m_opaque_entries;
 };
 
-inline constexpr const char* PLUGIN_OVERRIDES_OPTION_KEY = "plugin_config_overrides";
-
-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);
+// Drops override entries for capabilities no longer named by any plugin-backed option in `config`
+// (e.g. slicing_pipeline_plugin cleared or pointed at another capability) and writes the result back
+// to `overrides_key`. Call it wherever such an option 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 `overrides_key` knows to refresh it.
+bool prune_stale_plugin_overrides(DynamicConfig& config, const std::string& overrides_key);
 
 struct EffectiveCapabilityConfig
 {

src/slic3r/plugin/PluginDescriptor.hpp

@@ -20,6 +20,7 @@ struct CloudPluginState
     bool update_available = false; // Cloud version > the local package version.
     bool unauthorized     = false; // Cloud plugin is valid locally, but cannot receive cloud updates.
     bool is_mine          = false; // Plugin was created (and uploaded) by the current user.
+    bool orphaned         = false; // Cloud identity remains locally, but the plugin is no longer subscribed/available.
 };
 
 enum class PluginUpdateStatus
@@ -106,6 +107,8 @@ struct PluginDescriptor
     {
         if (!cloud.has_value())
             return PluginUpdateStatus::Normal;
+        if (cloud->orphaned)
+            return PluginUpdateStatus::Normal;
         if (cloud->unauthorized)
             return PluginUpdateStatus::Unauthorized;
         if (cloud->update_available)

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) {
@@ -330,12 +331,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,
@@ -1454,7 +1490,8 @@ void PluginManager::fetch_plugins_from_cloud(std::vector<std::string>* out_not_f
 
     std::vector<PluginDescriptor> cloud_list{};
     std::vector<std::string> not_found{}, unauthorized{};
-    if (!m_cloud_service.fetch_manifests_into_descriptors(cloud_list, not_found, unauthorized)) {
+    const bool cloud_fetch_succeeded = m_cloud_service.fetch_manifests_into_descriptors(cloud_list, not_found, unauthorized);
+    if (!cloud_fetch_succeeded) {
         if (wxTheApp != nullptr) {
             GUI::wxGetApp().CallAfter([] {
                 if (GUI::wxGetApp().is_closing())
@@ -1469,9 +1506,10 @@ void PluginManager::fetch_plugins_from_cloud(std::vector<std::string>* out_not_f
         }
     }
 
-    update_cloud_metadata(cloud_list);
+    if (cloud_fetch_succeeded)
+        update_cloud_metadata(cloud_list);
 
-    {
+    if (cloud_fetch_succeeded) {
         std::lock_guard<std::mutex> lock(m_mutex);
 
         // Clear the previous cloud verdicts before re-applying the fresh ones.
@@ -1480,19 +1518,28 @@ void PluginManager::fetch_plugins_from_cloud(std::vector<std::string>* out_not_f
             if (!entry.is_cloud_plugin())
                 continue;
             entry.set_unauthorized(false);
+            if (entry.cloud.has_value())
+                entry.cloud->orphaned = false;
             if (entry.normalized_error() == CLOUD_PLUGIN_NOT_FOUND_ERROR)
                 entry.clear_error();
         }
 
-        for (const std::string& uuid : not_found) {
-            for (Plugin& plugin : m_plugins) {
-                PluginDescriptor& entry = plugin.descriptor;
-                if (!entry.is_cloud_plugin() || entry.cloud_uuid() != uuid)
-                    continue;
-                if (!entry.has_local_package())
-                    entry.set_error(CLOUD_PLUGIN_NOT_FOUND_ERROR);
-                break;
-            }
+        // A successful subscriptions response may report missing UUIDs explicitly, or it may
+        // simply omit an unsubscribed plugin from `data`. Both cases leave a locally retained
+        // cloud package orphaned. Owned plugins are returned by the separate mine endpoint and
+        // must not be orphaned merely because they are not subscribed.
+        for (Plugin& plugin : m_plugins) {
+            PluginDescriptor& entry = plugin.descriptor;
+            if (!entry.is_cloud_plugin() || entry.cloud->is_mine)
+                continue;
+
+            const bool explicitly_not_found = std::find(not_found.begin(), not_found.end(), entry.cloud_uuid()) != not_found.end();
+            const bool returned_by_cloud = std::any_of(cloud_list.begin(), cloud_list.end(), [&entry](const PluginDescriptor& cloud_entry) {
+                return cloud_entry.cloud_uuid() == entry.cloud_uuid();
+            });
+            entry.cloud->orphaned = explicitly_not_found || !returned_by_cloud;
+            if (entry.cloud->orphaned)
+                entry.cloud->update_available = false;
         }
 
         for (const std::string& uuid : unauthorized) {
@@ -1889,7 +1936,7 @@ bool PluginManager::unsubscribe_cloud_plugin(const std::string& plugin_key, std:
     }
 
     if (descriptor.cloud && descriptor.cloud->is_mine) {
-        error = "Cannot unsubscribe your own plugins. Use Delete from Cloud instead.";
+        error = "Cannot unsubscribe your own plugins.";
         set_plugin_error(plugin_key, error);
         return false;
     }
@@ -1922,7 +1969,7 @@ bool PluginManager::delete_and_unsubscribe_cloud_plugin(const std::string& plugi
     }
 
     if (descriptor.cloud->is_mine) {
-        error = "Use Delete local and cloud for owned plugins.";
+        error = "Cannot unsubscribe your own plugins. Use Delete to remove the local files.";
         set_plugin_error(plugin_key, error);
         return false;
     }
@@ -1935,72 +1982,6 @@ bool PluginManager::delete_and_unsubscribe_cloud_plugin(const std::string& plugi
     return finalize_cloud_plugin_removal(descriptor, false, error);
 }
 
-bool PluginManager::delete_mine_plugin_from_cloud(const std::string& plugin_key, std::string& error)
-{
-    if (!wait_for_discovery(std::chrono::milliseconds::max(), error))
-        return false;
-
-    error.clear();
-
-    PluginDescriptor descriptor;
-    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
-        error = "Plugin not found: " + plugin_key;
-        return false;
-    }
-
-    if (!descriptor.is_cloud_plugin()) {
-        error = "Only owned cloud plugins can be deleted from the cloud.";
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    if (!descriptor.cloud->is_mine) {
-        error = "Only your own plugins can be deleted from the cloud.";
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    if (!m_cloud_service.request_cloud_delete(descriptor, error)) {
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    return finalize_cloud_plugin_removal(descriptor, true, error);
-}
-
-bool PluginManager::delete_mine_local_and_cloud_plugin(const std::string& plugin_key, std::string& error)
-{
-    if (!wait_for_discovery(std::chrono::milliseconds::max(), error))
-        return false;
-
-    error.clear();
-
-    PluginDescriptor descriptor;
-    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
-        error = "Plugin not found: " + plugin_key;
-        return false;
-    }
-
-    if (!descriptor.is_cloud_plugin()) {
-        error = "Only owned cloud plugins can be deleted from local and cloud.";
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    if (!descriptor.cloud->is_mine) {
-        error = "Only your own plugins can be deleted from local and cloud.";
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    if (!m_cloud_service.request_cloud_delete(descriptor, error)) {
-        set_plugin_error(plugin_key, error);
-        return false;
-    }
-
-    return finalize_cloud_plugin_removal(descriptor, false, error);
-}
-
 ExecutionResult PluginManager::run_script_capability(const std::string& plugin_key, const std::string& capability_name, std::string& error)
 {
     if (plugin_key.empty() || capability_name.empty()) {

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.
@@ -200,8 +205,6 @@ public:
     bool delete_plugin(const std::string& plugin_key, std::string& error);
     bool unsubscribe_cloud_plugin(const std::string& plugin_key, std::string& error);
     bool delete_and_unsubscribe_cloud_plugin(const std::string& plugin_key, std::string& error);
-    bool delete_mine_plugin_from_cloud(const std::string& plugin_key, std::string& error);
-    bool delete_mine_local_and_cloud_plugin(const std::string& plugin_key, std::string& error);
 
     ExecutionResult run_script_capability(const std::string& plugin_key, const std::string& capability_name, std::string& error);
 
@@ -268,6 +271,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

src/slic3r/plugin/host/PluginHostApp.cpp

@@ -2,6 +2,7 @@
 
 #include <libslic3r/Model.hpp>
 #include <libslic3r/PresetBundle.hpp>
+#include <slic3r/GUI/GUI.hpp>
 #include <slic3r/GUI/GUI_App.hpp>
 #include <slic3r/GUI/Plater.hpp>
 
@@ -55,6 +56,15 @@ void host_bindings::register_app(py::module_& host)
         return current_plater()->model();
     }, py::return_value_policy::reference);
     host.def("preset_bundle", &current_preset_bundle, py::return_value_policy::reference);
+    // UI language of the running app ("en_US", "ru_RU", ...), so plugins can
+    // localize their own dialogs. The app config file that stores this value
+    // is deny-listed by the audit hook (it sits next to cloud secrets), so a
+    // read-only accessor is the supported way to get just the language.
+    host.def("app_language", []() -> std::string {
+        if (wxTheApp == nullptr)
+            throw std::runtime_error("OrcaSlicer application is not initialized");
+        return GUI::into_u8(GUI::wxGetApp().current_language_code_safe());
+    });
 }
 
 } // namespace Slic3r