Added export and import of plugin archives (#885)

Co-authored-by: Thorsten Sommer <SommerEngineering@users.noreply.github.com>

app/MindWork AI Studio/Tools/PluginSystem/PluginArchive.cs

@@ -0,0 +1,80 @@
+using System.IO.Compression;
+
+namespace AIStudio.Tools.PluginSystem;
+
+public static class PluginArchive
+{
+    /// <summary>
+    /// The file extension of plugin archives.
+    /// </summary>
+    /// <remarks>
+    /// Keep in sync with SHARE_FILE_EXTENSION in runtime/src/share_sheet.rs: the runtime only hands
+    /// archives with this extension to the native share sheet.
+    /// </remarks>
+    public const string PLUGIN_FILE_EXTENSION = ".mwplugin";
+
+
+    // Compatibility shim for Windows-created ZIPs with backslashes in entry names (dotnet/runtime#27620);
+    // remove after dotnet/runtime#27620 and #41914 are fixed.
+    // See documentation/compatibility-shims/2026-07-plugin-archive-zip-backslashes.md.
+    public static void Extract(string sourceArchiveFileName, string destinationDirectory)
+    {
+        using var archive = ZipFile.OpenRead(sourceArchiveFileName);
+        Directory.CreateDirectory(destinationDirectory);
+
+        var destinationDirectoryFullPath = Path.GetFullPath(destinationDirectory);
+        if (!destinationDirectoryFullPath.EndsWith(Path.DirectorySeparatorChar))
+            destinationDirectoryFullPath += Path.DirectorySeparatorChar;
+
+        foreach (var entry in archive.Entries)
+        {
+            var normalizedEntryName = NormalizeEntryName(entry.FullName);
+            var destinationPath = GetEntryDestinationPath(destinationDirectoryFullPath, normalizedEntryName);
+
+            if (normalizedEntryName.EndsWith('/'))
+            {
+                if (entry.Length != 0)
+                    throw new InvalidDataException($"The plugin archive contains a directory entry with data: '{entry.FullName}'.");
+
+                Directory.CreateDirectory(destinationPath);
+                continue;
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
+            entry.ExtractToFile(destinationPath);
+        }
+    }
+
+    private static string NormalizeEntryName(string entryName)
+    {
+        var normalizedEntryName = entryName.Replace('\\', '/');
+        if (string.IsNullOrWhiteSpace(normalizedEntryName))
+            throw new InvalidDataException("The plugin archive contains an empty entry name.");
+
+        if (normalizedEntryName.Contains('\0'))
+            throw new InvalidDataException($"The plugin archive contains an invalid entry name: '{entryName}'.");
+
+        if (normalizedEntryName.StartsWith('/'))
+            throw new InvalidDataException($"The plugin archive contains a rooted entry name: '{entryName}'.");
+
+        if (normalizedEntryName is [_, ':', ..])
+            throw new InvalidDataException($"The plugin archive contains a drive-qualified entry name: '{entryName}'.");
+
+        var pathSegments = normalizedEntryName.Split('/', StringSplitOptions.RemoveEmptyEntries);
+        if (pathSegments.Length == 0 || pathSegments.Any(segment => segment is "." or ".."))
+            throw new InvalidDataException($"The plugin archive contains an unsafe entry name: '{entryName}'.");
+
+        return normalizedEntryName;
+    }
+
+    private static string GetEntryDestinationPath(string destinationDirectoryFullPath, string normalizedEntryName)
+    {
+        var pathSegments = normalizedEntryName.Split('/', StringSplitOptions.RemoveEmptyEntries);
+        var relativePath = Path.Combine(pathSegments);
+        var destinationPath = Path.GetFullPath(Path.Combine(destinationDirectoryFullPath, relativePath));
+        if (!destinationPath.StartsWith(destinationDirectoryFullPath, StringComparison.Ordinal))
+            throw new InvalidDataException($"The plugin archive contains an entry outside the destination directory: '{normalizedEntryName}'.");
+
+        return destinationPath;
+    }
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginConfiguration.cs

@@ -179,6 +179,12 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
         // Config: allow the user to add providers?
         ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.AllowUserToAddProvider, this.Id, settingsTable, dryRun);
 
+        // Config: allow the user to import plugin archives?
+        ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.AllowUserToImportPlugins, this.Id, settingsTable, dryRun);
+
+        // Config: allow the user to share or export plugins?
+        ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.AllowUserToSharePlugins, this.Id, settingsTable, dryRun);
+
         // Config: show administration settings?
         ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.ShowAdminSettings, this.Id, settingsTable, dryRun);
         

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Download.cs

@@ -1,4 +1,3 @@
-using System.IO.Compression;
 using System.Net.Http.Headers;
 
 namespace AIStudio.Tools.PluginSystem;
@@ -130,69 +129,11 @@ public static partial class PluginFactory
         return wasSuccessful;
     }
 
-    // Compatibility shim for Windows-created ZIPs with backslashes in entry names (dotnet/runtime#27620).
-    // See documentation/compatibility-shims/2026-07-enterprise-config-zip-backslashes.md.
     private static void ExtractConfigPluginArchive(string sourceArchiveFileName, string destinationDirectory)
     {
-        using var archive = ZipFile.OpenRead(sourceArchiveFileName);
-        Directory.CreateDirectory(destinationDirectory);
-
-        var destinationDirectoryFullPath = Path.GetFullPath(destinationDirectory);
-        if (!destinationDirectoryFullPath.EndsWith(Path.DirectorySeparatorChar))
-            destinationDirectoryFullPath += Path.DirectorySeparatorChar;
-
-        foreach (var entry in archive.Entries)
-        {
-            var normalizedEntryName = NormalizeConfigPluginZipEntryName(entry.FullName);
-            var destinationPath = GetConfigPluginZipEntryDestinationPath(destinationDirectoryFullPath, normalizedEntryName);
-
-            if (normalizedEntryName.EndsWith('/'))
-            {
-                if (entry.Length != 0)
-                    throw new InvalidDataException($"The enterprise configuration plugin archive contains a directory entry with data: '{entry.FullName}'.");
-
-                Directory.CreateDirectory(destinationPath);
-                continue;
-            }
-
-            Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
-            entry.ExtractToFile(destinationPath);
-        }
+        PluginArchive.Extract(sourceArchiveFileName, destinationDirectory);
 
         if (!Directory.EnumerateFiles(destinationDirectory, "plugin.lua", SearchOption.AllDirectories).Any())
             throw new InvalidDataException("The enterprise configuration plugin archive does not contain a plugin.lua file.");
     }
-
-    private static string NormalizeConfigPluginZipEntryName(string entryName)
-    {
-        var normalizedEntryName = entryName.Replace('\\', '/');
-        if (string.IsNullOrWhiteSpace(normalizedEntryName))
-            throw new InvalidDataException("The enterprise configuration plugin archive contains an empty entry name.");
-
-        if (normalizedEntryName.Contains('\0'))
-            throw new InvalidDataException($"The enterprise configuration plugin archive contains an invalid entry name: '{entryName}'.");
-
-        if (normalizedEntryName.StartsWith('/'))
-            throw new InvalidDataException($"The enterprise configuration plugin archive contains a rooted entry name: '{entryName}'.");
-
-        if (normalizedEntryName is [_, ':', ..])
-            throw new InvalidDataException($"The enterprise configuration plugin archive contains a drive-qualified entry name: '{entryName}'.");
-
-        var pathSegments = normalizedEntryName.Split('/', StringSplitOptions.RemoveEmptyEntries);
-        if (pathSegments.Length == 0 || pathSegments.Any(segment => segment is "." or ".."))
-            throw new InvalidDataException($"The enterprise configuration plugin archive contains an unsafe entry name: '{entryName}'.");
-
-        return normalizedEntryName;
-    }
-
-    private static string GetConfigPluginZipEntryDestinationPath(string destinationDirectoryFullPath, string normalizedEntryName)
-    {
-        var pathSegments = normalizedEntryName.Split('/', StringSplitOptions.RemoveEmptyEntries);
-        var relativePath = Path.Combine(pathSegments);
-        var destinationPath = Path.GetFullPath(Path.Combine(destinationDirectoryFullPath, relativePath));
-        if (!destinationPath.StartsWith(destinationDirectoryFullPath, StringComparison.Ordinal))
-            throw new InvalidDataException($"The enterprise configuration plugin archive contains an entry outside the destination directory: '{normalizedEntryName}'.");
-
-        return destinationPath;
-    }
-}
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Loading.cs

@@ -265,6 +265,14 @@ public static partial class PluginFactory
         if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.AllowUserToAddProvider, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
 
+        // Check for the plugin import permission:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.AllowUserToImportPlugins, AVAILABLE_PLUGINS))
+            wasConfigurationChanged = true;
+
+        // Check for the plugin sharing permission:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.AllowUserToSharePlugins, AVAILABLE_PLUGINS))
+            wasConfigurationChanged = true;
+
         // Check for admin settings visibility:
         if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.ShowAdminSettings, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
@@ -377,16 +385,24 @@ public static partial class PluginFactory
         }
     }
 
-    public static async Task<PluginBase> Load(string? pluginPath, string code, CancellationToken cancellationToken = default)
+    /// <param name="pluginPath">The directory the plugin is located in, or null when the code has no directory yet.</param>
+    /// <param name="code">The Lua code of the plugin's main file.</param>
+    /// <param name="cancellationToken">Cancellation token for running the Lua code.</param>
+    /// <param name="allowedBaseDirectory">
+    /// The directory the plugin path must be nested in. Without it, the installed plugins directory
+    /// is used. Validating a plugin before its installation needs this, because the plugin lives in
+    /// a staging directory at that point and could not load any of its own Lua modules otherwise.
+    /// </param>
+    public static async Task<PluginBase> Load(string? pluginPath, string code, CancellationToken cancellationToken = default, string? allowedBaseDirectory = null)
     {
         if(ForbiddenPlugins.Check(code) is { IsForbidden: true } forbiddenState)
             return new NoPlugin($"This plugin is forbidden: {forbiddenState.Message}");
-        
+
         var state = LuaState.Create();
         if (!string.IsNullOrWhiteSpace(pluginPath))
         {
             // Add the module loader so that the plugin can load other Lua modules:
-            state.ModuleLoader = new PluginLoader(pluginPath);
+            state.ModuleLoader = new PluginLoader(pluginPath, allowedBaseDirectory);
         }
 
         // Add some useful libraries:

app/MindWork AI Studio/Tools/PluginSystem/PluginLoader.cs

@@ -14,10 +14,17 @@ namespace AIStudio.Tools.PluginSystem;
 /// Loading other modules outside the plugin directory is not allowed.
 /// </remarks>
 /// <param name="pluginDirectory">The directory where the plugin is located.</param>
-public sealed class PluginLoader(string pluginDirectory) : ILuaModuleLoader
+/// <param name="allowedBaseDirectory">
+/// The directory the plugin directory must be nested in. Without it, the installed plugins directory
+/// is used. Validating a plugin before its installation needs this, because the plugin is not
+/// installed yet and lives in a staging directory outside the installed plugins directory.
+/// </param>
+public sealed class PluginLoader(string pluginDirectory, string? allowedBaseDirectory = null) : ILuaModuleLoader
 {
     private static readonly string PLUGIN_BASE_PATH = Path.Join(SettingsManager.DataDirectory, "plugins");
 
+    private readonly string baseDirectory = string.IsNullOrWhiteSpace(allowedBaseDirectory) ? PLUGIN_BASE_PATH : allowedBaseDirectory;
+
     #region Implementation of ILuaModuleLoader
 
     /// <inheritdoc />
@@ -26,11 +33,11 @@ public sealed class PluginLoader(string pluginDirectory) : ILuaModuleLoader
         // Ensure that the user doesn't try to escape the plugin directory:
         if (moduleName.Contains("..") || pluginDirectory.Contains(".."))
             return false;
-        
-        // Ensure that the plugin directory is nested in the plugin base path:
-        if (!pluginDirectory.StartsWith(PLUGIN_BASE_PATH, StringComparison.OrdinalIgnoreCase))
+
+        // Ensure that the plugin directory is nested in the allowed base directory:
+        if (!pluginDirectory.StartsWith(this.baseDirectory, StringComparison.OrdinalIgnoreCase))
             return false;
-        
+
         var path = Path.Join(pluginDirectory, $"{moduleName}.lua");
         return File.Exists(path);
     }
@@ -40,7 +47,7 @@ public sealed class PluginLoader(string pluginDirectory) : ILuaModuleLoader
     {
         var path = Path.Join(pluginDirectory, $"{moduleName}.lua");
         var code = await File.ReadAllTextAsync(path, Encoding.UTF8, cancellationToken);
-		
+
         return new(moduleName, code);
     }