mirror of
https://github.com/MindWorkAI/AI-Studio.git
synced 2026-08-11 18:32:12 +00:00
Split the plugin install service into partial classes
This commit is contained in:
Thorsten Sommer
parent
0d8d8890a4
commit
ffc5b8a882
GPG Key ID:
371BBA77A02C0108
@ -0,0 +1,116 @@
|
||||
using System.Text;
|
||||
using AIStudio.Tools.PluginSystem;
|
||||
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
/// <summary>
|
||||
/// Checks whether generated Lua assistant plugin code can be loaded and installed.
|
||||
/// The plugin is written to a temporary staging directory and validated through the
|
||||
/// normal plugin loader, but it is not moved into the user plugin directory.
|
||||
/// </summary>
|
||||
/// <param name="lua">The full generated <c>plugin.lua</c> content.</param>
|
||||
/// <param name="token">A cancellation token for file IO and Lua validation.</param>
|
||||
/// <returns>
|
||||
/// Check result that contains success state, plugin metadata, and a user-facing issue when validation failed.
|
||||
/// </returns>
|
||||
public async Task<AssistantPluginCheckResult> CheckInstallabilityAsync(string lua, CancellationToken token)
|
||||
{
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return CheckError(rootIssue);
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
var stagingDirectory = string.Empty;
|
||||
try
|
||||
{
|
||||
var validation = await this.ValidateIntoStagingAsync(lua, token);
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
return CheckError(validation.Issue);
|
||||
|
||||
stagingDirectory = validation.StagingDirectory;
|
||||
var finalDirectory = DetermineFinalDirectory(assistantPluginsRoot, validation.AssistantPlugin, PluginType.ASSISTANT);
|
||||
if (!IsPathInsideDirectory(assistantPluginsRoot, finalDirectory))
|
||||
return CheckError(TB("The resolved plugin directory is outside the plugin directory."));
|
||||
|
||||
return new(true, validation.AssistantPlugin.Id, validation.AssistantPlugin.Name, string.Empty);
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.TryDeleteStagingDirectory(stagingDirectory);
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Installs generated Lua assistant plugin code into the user plugin directory.
|
||||
/// Writes the plugin into a temporary staging directory first, validates it through the
|
||||
/// normal plugin loader, then moves into <c>data/plugins/assistants</c>.
|
||||
/// If plugin with same ID already exists, the existing directory is moved
|
||||
/// aside as backup and restored when replacement fails.
|
||||
/// </summary>
|
||||
/// <param name="lua">The full generated <c>plugin.lua</c> content.</param>
|
||||
/// <param name="token">A cancellation token for file IO, Lua validation, and plugin reload.</param>
|
||||
/// <returns>
|
||||
/// Installation result that contains success state, installed plugin metadata, final directory,
|
||||
/// whether an existing plugin was replaced, and user-facing issue when installation failed.
|
||||
/// </returns>
|
||||
public async Task<AssistantPluginInstallResult> InstallAsync(string lua, CancellationToken token)
|
||||
{
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return Error(rootIssue);
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
try
|
||||
{
|
||||
var validation = await this.ValidateIntoStagingAsync(lua, token);
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
return Error(validation.Issue);
|
||||
|
||||
return await this.InstallStagedPluginAsync(assistantPluginsRoot, validation, PluginType.ASSISTANT, token);
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<PluginValidationResult> ValidateIntoStagingAsync(string lua, CancellationToken token)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(lua))
|
||||
return PluginValidationResult.Failure(TB("No Lua plugin code was generated."));
|
||||
|
||||
if (!PluginFactory.IsInitialized)
|
||||
return PluginValidationResult.Failure(TB("The plugin system is not initialized yet."));
|
||||
|
||||
var pluginCode = lua.Trim();
|
||||
var stagingDirectory = Path.Join(Path.GetTempPath(), $"{ASSISTANT_BUILDER_DIRECTORY_PREFIX}.staging-{Guid.NewGuid():N}");
|
||||
|
||||
try
|
||||
{
|
||||
Directory.CreateDirectory(stagingDirectory);
|
||||
var stagedPluginFile = Path.Join(stagingDirectory, PLUGIN_FILE_NAME);
|
||||
await File.WriteAllTextAsync(stagedPluginFile, pluginCode, Encoding.UTF8, token);
|
||||
|
||||
var validation = await ValidatePluginCodeAsync(
|
||||
stagingDirectory,
|
||||
pluginCode,
|
||||
PluginType.ASSISTANT,
|
||||
TB("The generated plugin is not an assistant plugin. Issue: {0}"),
|
||||
TB("The generated assistant plugin is invalid. Issue: {0}"),
|
||||
TB("The generated assistant plugin uses the ID of another installed plugin."),
|
||||
token);
|
||||
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
this.TryDeleteStagingDirectory(stagingDirectory);
|
||||
|
||||
return validation with { StagingDirectory = stagingDirectory };
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, "Failed to validate generated assistant plugin.");
|
||||
this.TryDeleteStagingDirectory(stagingDirectory);
|
||||
return PluginValidationResult.Failure(string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,308 @@
|
||||
using AIStudio.Settings;
|
||||
using AIStudio.Tools.Media;
|
||||
using AIStudio.Tools.PluginSystem;
|
||||
using AIStudio.Tools.PluginSystem.Assistants;
|
||||
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
/// <summary>
|
||||
/// Checks whether a local plugin is an Assistant Builder generated assistant that users may delete.
|
||||
/// </summary>
|
||||
public static bool CanDeleteInstalledAssistant(IAvailablePlugin plugin) => string.IsNullOrWhiteSpace(GetAssistantDeletionEligibilityIssue(plugin));
|
||||
|
||||
/// <summary>
|
||||
/// Checks whether a plugin is a local configuration plugin that users may delete.
|
||||
/// </summary>
|
||||
public static bool CanDeleteInstalledConfiguration(IAvailablePlugin plugin) => string.IsNullOrWhiteSpace(GetConfigurationDeletionEligibilityIssue(plugin));
|
||||
|
||||
/// <summary>
|
||||
/// Collects what deleting a local configuration plugin removes besides the plugin directory.
|
||||
/// </summary>
|
||||
/// <param name="plugin">The configuration plugin about to be deleted.</param>
|
||||
/// <returns>
|
||||
/// The summary shown to the user before the deletion starts. It is empty when the plugin is not
|
||||
/// running, because we cannot tell what an unloadable plugin had configured.
|
||||
/// </returns>
|
||||
public ConfigurationPluginDeleteSummary BuildConfigurationDeleteSummary(IAvailablePlugin plugin)
|
||||
{
|
||||
var configurationPlugin = PluginFactory.RunningPlugins.OfType<PluginConfiguration>().FirstOrDefault(candidate => candidate.Id == plugin.Id);
|
||||
if (configurationPlugin is null)
|
||||
return ConfigurationPluginDeleteSummary.EMPTY;
|
||||
|
||||
var configObjects = configurationPlugin.ConfigObjects.ToList();
|
||||
var configurationData = this.settingsManager.ConfigurationData;
|
||||
|
||||
// Both maps record which configuration plugin manages a setting. Everything this plugin owns
|
||||
// returns to its default value once the plugin is gone:
|
||||
var lockedSettings =
|
||||
configurationData.ManagedLockedConfigurations.Count(entry => entry.Value == plugin.Id) +
|
||||
configurationData.ManagedEditableDefaults.Count(entry => entry.Value.ConfigPluginId == plugin.Id);
|
||||
|
||||
return new(
|
||||
LlmProviders: CountObjects(PluginConfigurationObjectType.LLM_PROVIDER),
|
||||
TranscriptionProviders: CountObjects(PluginConfigurationObjectType.TRANSCRIPTION_PROVIDER),
|
||||
EmbeddingProviders: CountObjects(PluginConfigurationObjectType.EMBEDDING_PROVIDER),
|
||||
DataSources: CountObjects(PluginConfigurationObjectType.DATA_SOURCE),
|
||||
ChatTemplates: CountObjects(PluginConfigurationObjectType.CHAT_TEMPLATE),
|
||||
Profiles: CountObjects(PluginConfigurationObjectType.PROFILE),
|
||||
DocumentAnalysisPolicies: CountObjects(PluginConfigurationObjectType.DOCUMENT_ANALYSIS_POLICY),
|
||||
LockedSettings: lockedSettings,
|
||||
MandatoryInfos: configurationPlugin.MandatoryInfos.Count,
|
||||
Introductions: configurationPlugin.Introductions.Count);
|
||||
|
||||
int CountObjects(PluginConfigurationObjectType type) => configObjects.Count(configObject => configObject.Type == type);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks whether an assistant still owns running or canceling background work.
|
||||
/// </summary>
|
||||
public bool HasActiveAssistantWork(Guid pluginId)
|
||||
{
|
||||
var instanceId = pluginId.ToString();
|
||||
if (this.assistantSessionService.GetSnapshots().Any(snapshot => snapshot.IsActive && string.Equals(snapshot.Key.InstanceId, instanceId, StringComparison.Ordinal)))
|
||||
return true;
|
||||
|
||||
var ownerIdSuffix = $":{instanceId}";
|
||||
return this.mediaTranscriptionService.GetSnapshots().Any(snapshot =>
|
||||
snapshot is { IsBusy: true, Owner.Kind: MediaImportOwnerKind.ASSISTANT } &&
|
||||
snapshot.Owner.Id.EndsWith(ownerIdSuffix, StringComparison.Ordinal));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes installed local assistant plugin directories.
|
||||
/// The directory gets moved to a backup dir outside the plugin root so the
|
||||
/// plugin loader cannot discover it during reload. On failure, the directory
|
||||
/// and related assistant settings are restored.
|
||||
/// </summary>
|
||||
/// <param name="plugin">Assistant plugin metadata</param>
|
||||
/// <param name="token">Cancellation token for settings storage and plugin reload</param>
|
||||
/// <returns>
|
||||
/// Delete result that contains success state, deleted plugin metadata, the original plugin directory,
|
||||
/// and a user-facing issue when deletion failed.
|
||||
/// </returns>
|
||||
public async Task<PluginDeleteResult> DeleteInstalledAssistantAsync(IAvailablePlugin plugin, CancellationToken token)
|
||||
{
|
||||
var eligibilityIssue = GetAssistantDeletionEligibilityIssue(plugin);
|
||||
if (!string.IsNullOrEmpty(eligibilityIssue))
|
||||
return DeleteError(plugin, plugin.LocalPath, eligibilityIssue);
|
||||
|
||||
if (this.HasActiveAssistantWork(plugin.Id))
|
||||
return DeleteError(plugin, plugin.LocalPath, TB("The assistant cannot be deleted while background work is still running."));
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
var pluginDirectory = plugin.LocalPath;
|
||||
var backupDirectory = string.Empty;
|
||||
var wasEnabled = false;
|
||||
var removedAudits = new List<PluginAssistantAudit>();
|
||||
|
||||
try
|
||||
{
|
||||
eligibilityIssue = GetAssistantDeletionEligibilityIssue(plugin);
|
||||
if (!string.IsNullOrEmpty(eligibilityIssue))
|
||||
return DeleteError(plugin, pluginDirectory, eligibilityIssue);
|
||||
|
||||
if (this.HasActiveAssistantWork(plugin.Id))
|
||||
return DeleteError(plugin, pluginDirectory, TB("The assistant cannot be deleted while background work is still running."));
|
||||
|
||||
backupDirectory = CreateDeleteBackupDirectory(plugin, "assistant");
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(backupDirectory)!);
|
||||
Directory.Move(pluginDirectory, backupDirectory);
|
||||
|
||||
wasEnabled = this.settingsManager.ConfigurationData.EnabledPlugins.Remove(plugin.Id);
|
||||
removedAudits =
|
||||
[
|
||||
.. this.settingsManager.ConfigurationData.AssistantPluginAudits.Where(audit => audit.PluginId == plugin.Id)
|
||||
];
|
||||
|
||||
if (removedAudits.Count > 0)
|
||||
this.settingsManager.ConfigurationData.AssistantPluginAudits.RemoveAll(audit => audit.PluginId == plugin.Id);
|
||||
|
||||
await this.settingsManager.StoreSettings();
|
||||
await PluginFactory.LoadAll(token);
|
||||
|
||||
TryDeleteDirectory(backupDirectory, "assistant plugin delete backup", this.logger);
|
||||
this.logger.LogInformation($"Deleted assistant plugin '{plugin.Name}' ({plugin.Id}) from '{pluginDirectory}'.");
|
||||
return new(true, plugin.Id, plugin.Name, pluginDirectory, string.Empty);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, $"Failed to delete assistant plugin '{plugin.Name}' ({plugin.Id}) from '{pluginDirectory}'.");
|
||||
|
||||
await this.TryRestoreDeletedAssistantPluginAsync(plugin, pluginDirectory, backupDirectory, wasEnabled, removedAudits, token);
|
||||
return DeleteError(plugin, pluginDirectory, string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes a local configuration plugin directory.
|
||||
/// The directory gets moved to a backup dir outside the plugin root so the plugin loader cannot
|
||||
/// discover it during reload. On failure, the directory is restored.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// We do not remove the providers, data sources, chat templates, profiles, or locked settings of
|
||||
/// the plugin ourselves. The reload does that: it recognizes them as left over once their
|
||||
/// configuration plugin is gone, and it also deletes the related secrets from the OS keyring.
|
||||
/// </remarks>
|
||||
/// <param name="plugin">Configuration plugin metadata.</param>
|
||||
/// <param name="token">Cancellation token for the plugin reload.</param>
|
||||
/// <returns>
|
||||
/// Delete result that contains success state, deleted plugin metadata, the original plugin directory,
|
||||
/// and a user-facing issue when deletion failed.
|
||||
/// </returns>
|
||||
public async Task<PluginDeleteResult> DeleteInstalledConfigurationAsync(IAvailablePlugin plugin, CancellationToken token)
|
||||
{
|
||||
var eligibilityIssue = GetConfigurationDeletionEligibilityIssue(plugin);
|
||||
if (!string.IsNullOrEmpty(eligibilityIssue))
|
||||
return DeleteError(plugin, plugin.LocalPath, eligibilityIssue);
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
var pluginDirectory = plugin.LocalPath;
|
||||
var backupDirectory = string.Empty;
|
||||
|
||||
try
|
||||
{
|
||||
// Check again under the semaphore: another operation might have changed the plugin state
|
||||
// while we were waiting:
|
||||
eligibilityIssue = GetConfigurationDeletionEligibilityIssue(plugin);
|
||||
if (!string.IsNullOrEmpty(eligibilityIssue))
|
||||
return DeleteError(plugin, pluginDirectory, eligibilityIssue);
|
||||
|
||||
backupDirectory = CreateDeleteBackupDirectory(plugin, "configuration");
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(backupDirectory)!);
|
||||
Directory.Move(pluginDirectory, backupDirectory);
|
||||
|
||||
await PluginFactory.LoadAll(token);
|
||||
|
||||
TryDeleteDirectory(backupDirectory, "configuration plugin delete backup", this.logger);
|
||||
this.logger.LogInformation($"Deleted configuration plugin '{plugin.Name}' ({plugin.Id}) from '{pluginDirectory}'.");
|
||||
return new(true, plugin.Id, plugin.Name, pluginDirectory, string.Empty);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, $"Failed to delete configuration plugin '{plugin.Name}' ({plugin.Id}) from '{pluginDirectory}'.");
|
||||
|
||||
await this.TryRestoreDeletedConfigurationPluginAsync(plugin, pluginDirectory, backupDirectory, token);
|
||||
return DeleteError(plugin, pluginDirectory, string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private static string GetAssistantDeletionEligibilityIssue(IAvailablePlugin plugin)
|
||||
{
|
||||
if (plugin.Type is not PluginType.ASSISTANT)
|
||||
return TB("Only assistant plugins can be deleted.");
|
||||
|
||||
if (plugin.IsInternal)
|
||||
return TB("Internal assistant plugins cannot be deleted.");
|
||||
|
||||
if (plugin.IsManagedByConfigServer)
|
||||
return TB("Config Server managed assistant plugins cannot be deleted.");
|
||||
|
||||
if (string.IsNullOrWhiteSpace(plugin.LocalPath))
|
||||
return TB("The assistant plugin has no local directory.");
|
||||
|
||||
var assistantPlugin = PluginFactory.RunningPlugins
|
||||
.OfType<PluginAssistants>()
|
||||
.FirstOrDefault(candidate => candidate.Id == plugin.Id && IsSameDirectory(candidate.PluginPath, plugin.LocalPath));
|
||||
|
||||
if (assistantPlugin is null || assistantPlugin.IsInternal || !assistantPlugin.IsAssistantBuilderGenerated)
|
||||
return TB("Only assistants generated by the Assistant Builder can be deleted.");
|
||||
|
||||
if (assistantPlugin.IsManagedByConfigServer)
|
||||
return TB("Config Server managed assistant plugins cannot be deleted.");
|
||||
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return rootIssue;
|
||||
|
||||
if (!IsPathInsideDirectory(assistantPluginsRoot, plugin.LocalPath) || IsSameDirectory(assistantPluginsRoot, plugin.LocalPath))
|
||||
return TB("The assistant plugin directory is outside the local assistant plugin directory.");
|
||||
|
||||
return Directory.Exists(plugin.LocalPath)
|
||||
? string.Empty
|
||||
: TB("The assistant plugin directory does not exist.");
|
||||
}
|
||||
|
||||
private static string GetConfigurationDeletionEligibilityIssue(IAvailablePlugin plugin)
|
||||
{
|
||||
if (plugin.Type is not PluginType.CONFIGURATION)
|
||||
return TB("Only configuration plugins can be deleted this way.");
|
||||
|
||||
if (plugin.IsInternal)
|
||||
return TB("Internal configuration plugins cannot be deleted.");
|
||||
|
||||
if (string.IsNullOrWhiteSpace(plugin.LocalPath))
|
||||
return TB("The configuration plugin has no local directory.");
|
||||
|
||||
//
|
||||
// We decide by the plugin path, not by IsManagedByConfigServer. That value comes from the
|
||||
// plugin's own DEPLOYED_USING_CONFIG_SERVER field: a locally placed plugin could declare
|
||||
// itself managed and would then be impossible to remove through the user interface, which
|
||||
// is exactly the situation this deletion is meant to resolve.
|
||||
//
|
||||
if (PluginFactory.IsEnterpriseConfigurationPath(plugin.LocalPath))
|
||||
return TB("Configuration plugins deployed by your organization cannot be deleted.");
|
||||
|
||||
if (!PluginFactory.IsInsidePluginsRoot(plugin.LocalPath))
|
||||
return TB("The configuration plugin directory is outside the plugins directory.");
|
||||
|
||||
return Directory.Exists(plugin.LocalPath)
|
||||
? string.Empty
|
||||
: TB("The configuration plugin directory does not exist.");
|
||||
}
|
||||
|
||||
private static string CreateDeleteBackupDirectory(IAvailablePlugin plugin, string pluginKind)
|
||||
{
|
||||
var backupRoot = Path.Join(SettingsManager.DataDirectory, DELETE_BACKUP_DIRECTORY);
|
||||
return Path.Join(backupRoot, $"{pluginKind}-{plugin.Id:N}-{Guid.NewGuid():N}");
|
||||
}
|
||||
|
||||
private async Task TryRestoreDeletedAssistantPluginAsync(IAvailablePlugin plugin, string pluginDirectory, string backupDirectory, bool wasEnabled, List<PluginAssistantAudit> removedAudits, CancellationToken token)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!Directory.Exists(pluginDirectory) && Directory.Exists(backupDirectory))
|
||||
Directory.Move(backupDirectory, pluginDirectory);
|
||||
|
||||
if (wasEnabled && !this.settingsManager.ConfigurationData.EnabledPlugins.Contains(plugin.Id))
|
||||
this.settingsManager.ConfigurationData.EnabledPlugins.Add(plugin.Id);
|
||||
|
||||
if (removedAudits.Count > 0)
|
||||
{
|
||||
this.settingsManager.ConfigurationData.AssistantPluginAudits.RemoveAll(audit => audit.PluginId == plugin.Id);
|
||||
this.settingsManager.ConfigurationData.AssistantPluginAudits.AddRange(removedAudits);
|
||||
}
|
||||
|
||||
await this.settingsManager.StoreSettings();
|
||||
await PluginFactory.LoadAll(token);
|
||||
}
|
||||
catch (Exception restoreException)
|
||||
{
|
||||
this.logger.LogError(restoreException, $"Failed to restore assistant plugin '{plugin.Name}' ({plugin.Id}) after a failed delete.");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task TryRestoreDeletedConfigurationPluginAsync(IAvailablePlugin plugin, string pluginDirectory, string backupDirectory, CancellationToken token)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!Directory.Exists(pluginDirectory) && Directory.Exists(backupDirectory))
|
||||
Directory.Move(backupDirectory, pluginDirectory);
|
||||
|
||||
// The reload restores everything the plugin configured, because it is back in place:
|
||||
await PluginFactory.LoadAll(token);
|
||||
}
|
||||
catch (Exception restoreException)
|
||||
{
|
||||
this.logger.LogError(restoreException, $"Failed to restore configuration plugin '{plugin.Name}' ({plugin.Id}) after a failed delete.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,195 @@
|
||||
using System.Text;
|
||||
using AIStudio.Tools.PluginSystem;
|
||||
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
/// <summary>
|
||||
/// Checks whether edited assistant plugin code can replace an installed local assistant plugin
|
||||
/// without writing the file.
|
||||
/// </summary>
|
||||
/// <param name="plugin">The installed local assistant plugin to validate against.</param>
|
||||
/// <param name="lua">The edited <c>plugin.lua</c> content.</param>
|
||||
/// <param name="token">Cancellation token for Lua validation.</param>
|
||||
/// <returns>Check result that contains success state, plugin metadata, and a user-facing issue when validation failed.</returns>
|
||||
public async Task<AssistantPluginCheckResult> CheckInstalledAssistantUpdateAsync(IAvailablePlugin plugin, string lua, CancellationToken token)
|
||||
{
|
||||
if (plugin.Type is not PluginType.ASSISTANT)
|
||||
return CheckError(TB("Only assistant plugins can be edited."));
|
||||
|
||||
if (plugin.IsInternal)
|
||||
return CheckError(TB("Internal assistant plugins cannot be edited."));
|
||||
|
||||
if (string.IsNullOrWhiteSpace(plugin.LocalPath))
|
||||
return CheckError(TB("The assistant plugin has no local directory."));
|
||||
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return CheckError(rootIssue);
|
||||
|
||||
var pluginDirectory = plugin.LocalPath;
|
||||
if (!IsPathInsideDirectory(assistantPluginsRoot, pluginDirectory) || IsSameDirectory(assistantPluginsRoot, pluginDirectory))
|
||||
return CheckError(TB("The assistant plugin directory is outside the local assistant plugin directory."));
|
||||
|
||||
if (!Directory.Exists(pluginDirectory))
|
||||
return CheckError(TB("The assistant plugin directory does not exist."));
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
try
|
||||
{
|
||||
var validation = await this.ValidateInPluginDirectoryAsync(lua, pluginDirectory, token);
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
return CheckError(validation.Issue);
|
||||
|
||||
var assistantPlugin = validation.AssistantPlugin;
|
||||
return assistantPlugin.Id != plugin.Id
|
||||
? CheckError(TB("The edited assistant plugin must keep the same plugin ID."))
|
||||
: new(true, assistantPlugin.Id, assistantPlugin.Name, string.Empty);
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates installed assistant plugin <c>plugin.lua</c> file.
|
||||
/// The edited Lua code is validated from the provided string before it is written,
|
||||
/// but validation uses existing plugin directory as loader context so
|
||||
/// <c>require(...)</c> can resolve companion files such as <c>icon.lua</c>.
|
||||
/// After successful validation, the current <c>plugin.lua</c> is backed up,
|
||||
/// replaced atomically through a temporary file in the plugin directory, and
|
||||
/// restored when the plugin reload fails.
|
||||
/// </summary>
|
||||
/// <param name="plugin">The installed local assistant plugin to update.</param>
|
||||
/// <param name="lua">The edited <c>plugin.lua</c> content.</param>
|
||||
/// <param name="token">Cancellation token for Lua validation, file IO, and plugin reload.</param>
|
||||
/// <returns>
|
||||
/// Update result that contains success state, updated plugin metadata, the plugin directory,
|
||||
/// and a user-facing issue when the update failed.
|
||||
/// </returns>
|
||||
public async Task<AssistantPluginUpdateResult> UpdateInstalledAssistantAsync(IAvailablePlugin plugin, string lua, CancellationToken token)
|
||||
{
|
||||
if (plugin.Type is not PluginType.ASSISTANT)
|
||||
return UpdateError(plugin, plugin.LocalPath, TB("Only assistant plugins can be edited."));
|
||||
|
||||
if (plugin.IsInternal)
|
||||
return UpdateError(plugin, plugin.LocalPath, TB("Internal assistant plugins cannot be edited."));
|
||||
|
||||
if (string.IsNullOrWhiteSpace(plugin.LocalPath))
|
||||
return UpdateError(plugin, string.Empty, TB("The assistant plugin has no local directory."));
|
||||
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return UpdateError(plugin, plugin.LocalPath, rootIssue);
|
||||
|
||||
var pluginDirectory = plugin.LocalPath;
|
||||
if (!IsPathInsideDirectory(assistantPluginsRoot, pluginDirectory) || IsSameDirectory(assistantPluginsRoot, pluginDirectory))
|
||||
return UpdateError(plugin, pluginDirectory, TB("The assistant plugin directory is outside the local assistant plugin directory."));
|
||||
|
||||
if (!Directory.Exists(pluginDirectory))
|
||||
return UpdateError(plugin, pluginDirectory, TB("The assistant plugin directory does not exist."));
|
||||
|
||||
var pluginFile = Path.Join(pluginDirectory, PLUGIN_FILE_NAME);
|
||||
if (!IsPathInsideDirectory(pluginDirectory, pluginFile))
|
||||
return UpdateError(plugin, pluginDirectory, TB("The plugin file is outside the assistant plugin directory."));
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
var tempFile = string.Empty;
|
||||
var backupFile = string.Empty;
|
||||
|
||||
try
|
||||
{
|
||||
var validation = await this.ValidateInPluginDirectoryAsync(lua, pluginDirectory, token);
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
return UpdateError(plugin, pluginDirectory, validation.Issue);
|
||||
|
||||
var assistantPlugin = validation.AssistantPlugin;
|
||||
if (assistantPlugin.Id != plugin.Id)
|
||||
return UpdateError(plugin, pluginDirectory, TB("The edited assistant plugin must keep the same plugin ID."));
|
||||
|
||||
var pluginCode = lua.Trim();
|
||||
tempFile = Path.Join(pluginDirectory, $"{PLUGIN_FILE_NAME}.tmp-{Guid.NewGuid():N}");
|
||||
backupFile = Path.Join(pluginDirectory, $"{PLUGIN_FILE_NAME}.backup-{Guid.NewGuid():N}");
|
||||
|
||||
await File.WriteAllTextAsync(tempFile, pluginCode, Encoding.UTF8, token);
|
||||
|
||||
if (File.Exists(pluginFile))
|
||||
File.Replace(tempFile, pluginFile, backupFile);
|
||||
else
|
||||
File.Move(tempFile, pluginFile);
|
||||
|
||||
try
|
||||
{
|
||||
await PluginFactory.LoadAll(token);
|
||||
if (File.Exists(backupFile))
|
||||
File.Delete(backupFile);
|
||||
|
||||
this.logger.LogInformation($"Updated assistant plugin '{assistantPlugin.Name}' ({assistantPlugin.Id}) at '{pluginFile}'.");
|
||||
return new(true, assistantPlugin.Id, assistantPlugin.Name, pluginDirectory, string.Empty);
|
||||
}
|
||||
catch (Exception reloadException)
|
||||
{
|
||||
this.logger.LogError(reloadException, $"Failed to reload plugins after editing assistant plugin '{plugin.Name}' ({plugin.Id}).");
|
||||
await this.TryRestoreEditedAssistantPluginAsync(pluginFile, backupFile, token);
|
||||
return UpdateError(plugin, pluginDirectory, string.Format(TB("Unexpected error: {0}"), reloadException.Message));
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, $"Failed to update assistant plugin '{plugin.Name}' ({plugin.Id}) at '{pluginDirectory}'.");
|
||||
await this.TryRestoreEditedAssistantPluginAsync(pluginFile, backupFile, token);
|
||||
return UpdateError(plugin, pluginDirectory, string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.TryDeleteFile(tempFile, "assistant plugin edit temp file");
|
||||
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<PluginValidationResult> ValidateInPluginDirectoryAsync(string lua, string pluginDirectory, CancellationToken token)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(lua))
|
||||
return PluginValidationResult.Failure(TB("No Lua plugin code was generated."));
|
||||
|
||||
if (!PluginFactory.IsInitialized)
|
||||
return PluginValidationResult.Failure(TB("The plugin system is not initialized yet."));
|
||||
|
||||
try
|
||||
{
|
||||
return await ValidatePluginCodeAsync(
|
||||
pluginDirectory,
|
||||
lua.Trim(),
|
||||
PluginType.ASSISTANT,
|
||||
TB("The edited plugin is not an assistant plugin. Issue: {0}"),
|
||||
TB("The edited assistant plugin is invalid. Issue: {0}"),
|
||||
TB("The edited assistant plugin uses the ID of another installed plugin."),
|
||||
token);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, "Failed to validate edited assistant plugin.");
|
||||
return PluginValidationResult.Failure(string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
}
|
||||
|
||||
private async Task TryRestoreEditedAssistantPluginAsync(string pluginFile, string backupFile, CancellationToken token)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(backupFile) || !File.Exists(backupFile))
|
||||
return;
|
||||
|
||||
if (File.Exists(pluginFile))
|
||||
File.Delete(pluginFile);
|
||||
|
||||
File.Move(backupFile, pluginFile);
|
||||
await PluginFactory.LoadAll(token);
|
||||
}
|
||||
catch (Exception restoreException)
|
||||
{
|
||||
this.logger.LogError(restoreException, $"Failed to restore assistant plugin file '{pluginFile}' after a failed edit.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
private static bool IsPathInsideDirectory(string parentDirectory, string path)
|
||||
{
|
||||
var parentPath = Path.GetFullPath(parentDirectory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
|
||||
var childPath = Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
|
||||
return childPath.StartsWith(parentPath, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
private static bool IsSameDirectory(string firstDirectory, string secondDirectory)
|
||||
{
|
||||
var firstPath = Path.GetFullPath(firstDirectory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
||||
var secondPath = Path.GetFullPath(secondDirectory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
||||
return string.Equals(firstPath, secondPath, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
private void TryDeleteStagingDirectory(string stagingDirectory) => TryDeleteDirectory(stagingDirectory, "assistant plugin staging", this.logger);
|
||||
|
||||
private static void TryDeleteDirectory(string directory, string directoryDescription, ILogger logger)
|
||||
{
|
||||
if (!Directory.Exists(directory))
|
||||
return;
|
||||
|
||||
try
|
||||
{
|
||||
Directory.Delete(directory, true);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
logger.LogError(e, $"Failed to delete {directoryDescription} directory '{directory}'.");
|
||||
}
|
||||
}
|
||||
|
||||
private void TryDeleteFile(string filePath, string fileDescription)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
|
||||
return;
|
||||
|
||||
try
|
||||
{
|
||||
File.Delete(filePath);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, $"Failed to delete {fileDescription} '{filePath}'.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,94 @@
|
||||
using System.Text;
|
||||
using AIStudio.Tools.PluginSystem;
|
||||
using AIStudio.Tools.Rust;
|
||||
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
/// <summary>
|
||||
/// Installs an assistant plugin archive that contains exactly one <c>plugin.lua</c> file.
|
||||
/// Companion files are validated from and moved with the same staging directory.
|
||||
/// </summary>
|
||||
/// <param name="archivePath">The local <c>.mwplugin</c> or <c>.zip</c> archive path.</param>
|
||||
/// <param name="confirmAsync">
|
||||
/// Asks the user whether the validated archive may be installed. It is called after all checks
|
||||
/// passed and before anything gets written. Returning false aborts the installation.
|
||||
/// </param>
|
||||
/// <param name="token">Cancellation token for extraction, validation, file IO, and plugin reload.</param>
|
||||
/// <returns>Installation result that contains success state, installed plugin metadata, and a user-facing issue when installation failed.</returns>
|
||||
public async Task<AssistantPluginInstallResult> InstallArchiveAsync(string archivePath, Func<PluginImportPreview, Task<bool>> confirmAsync, CancellationToken token)
|
||||
{
|
||||
if (!this.settingsManager.ConfigurationData.App.AllowUserToImportPlugins)
|
||||
return Error(TB("Your organization has disabled importing plugins."));
|
||||
|
||||
if (!FileTypes.IsAllowedPath(archivePath, FileTypes.PLUGIN_ARCHIVE))
|
||||
return Error(TB("Please select a plugin archive with the extension .mwplugin or .zip."));
|
||||
|
||||
if (!File.Exists(archivePath))
|
||||
return Error(TB("The selected plugin archive does not exist."));
|
||||
|
||||
if (!TryGetPluginRoot(PluginType.ASSISTANT, out var assistantPluginsRoot, out var rootIssue))
|
||||
return Error(rootIssue);
|
||||
|
||||
if (!PluginFactory.IsInitialized)
|
||||
return Error(TB("The plugin system is not initialized yet."));
|
||||
|
||||
await this.installSemaphore.WaitAsync(token);
|
||||
var stagingDirectory = Path.Join(Path.GetTempPath(), $"assistant-plugin-import.staging-{Guid.NewGuid():N}");
|
||||
try
|
||||
{
|
||||
token.ThrowIfCancellationRequested();
|
||||
PluginArchive.Extract(archivePath, stagingDirectory);
|
||||
|
||||
var pluginFiles = Directory.EnumerateFiles(stagingDirectory, PLUGIN_FILE_NAME, SearchOption.AllDirectories).ToArray();
|
||||
if (pluginFiles.Length != 1)
|
||||
return Error(TB("The plugin archive must contain exactly one plugin.lua file."));
|
||||
|
||||
var pluginFile = pluginFiles[0];
|
||||
var pluginDirectory = Path.GetDirectoryName(pluginFile)!;
|
||||
var pluginCode = await File.ReadAllTextAsync(pluginFile, Encoding.UTF8, token);
|
||||
var validation = await ValidatePluginCodeAsync(
|
||||
pluginDirectory,
|
||||
pluginCode.Trim(),
|
||||
PluginType.ASSISTANT,
|
||||
TB("Currently, only assistant plugins can be imported."),
|
||||
TB("The imported assistant plugin is invalid. Issue: {0}"),
|
||||
TB("The imported assistant plugin uses the ID of another installed plugin."),
|
||||
token);
|
||||
|
||||
if (!validation.Success || validation.AssistantPlugin is null)
|
||||
return Error(validation.Issue);
|
||||
|
||||
// A plugin the user imports by hand never comes from a config server. We reject such
|
||||
// archives because AI Studio trusts this self-declared flag: an imported plugin
|
||||
// claiming it would be neither replaceable nor deletable through the user interface:
|
||||
if (validation.AssistantPlugin.IsManagedByConfigServer)
|
||||
return Error(TB("This plugin archive declares itself as managed by a config server. Only the IT department of your organization might deploy such plugins."));
|
||||
|
||||
// The archive would replace an existing plugin: reject it when that plugin belongs
|
||||
// to the IT department. We check this before asking the user, so that the
|
||||
// confirmation never offers something we would refuse afterwards anyway:
|
||||
var replacementIssue = GetReplacementIssue(validation.AssistantPlugin.Id, PluginType.ASSISTANT);
|
||||
if (!string.IsNullOrEmpty(replacementIssue))
|
||||
return Error(replacementIssue);
|
||||
|
||||
// Everything is validated, but nothing was written yet. This is the point where the
|
||||
// user decides, because the plugin code comes from an untrusted source:
|
||||
if (!await confirmAsync(CreateImportPreview(validation.AssistantPlugin)))
|
||||
return CancelledByUser();
|
||||
|
||||
return await this.InstallStagedPluginAsync(assistantPluginsRoot, validation with { StagingDirectory = pluginDirectory }, PluginType.ASSISTANT, token);
|
||||
}
|
||||
catch (Exception e) when (e is not OperationCanceledException)
|
||||
{
|
||||
this.logger.LogError(e, "Failed to extract or validate assistant plugin archive '{ArchivePath}'.", archivePath);
|
||||
return Error(string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.TryDeleteStagingDirectory(stagingDirectory);
|
||||
this.installSemaphore.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,252 @@
|
||||
using System.Text;
|
||||
using AIStudio.Settings;
|
||||
using AIStudio.Tools.PluginSystem;
|
||||
using AIStudio.Tools.PluginSystem.Assistants;
|
||||
|
||||
namespace AIStudio.Tools.Services;
|
||||
|
||||
public sealed partial class PluginInstallService
|
||||
{
|
||||
private async Task<AssistantPluginInstallResult> InstallStagedPluginAsync(string pluginRoot, PluginValidationResult validation, PluginType pluginType, CancellationToken token)
|
||||
{
|
||||
var stagingDirectory = validation.StagingDirectory;
|
||||
var plugin = validation.Plugin!;
|
||||
string? backupDirectory = null;
|
||||
string? finalDirectory = null;
|
||||
var replacedExisting = false;
|
||||
var movedIntoPlace = false;
|
||||
|
||||
try
|
||||
{
|
||||
Directory.CreateDirectory(pluginRoot);
|
||||
finalDirectory = DetermineFinalDirectory(pluginRoot, plugin, pluginType);
|
||||
if (!IsPathInsideDirectory(pluginRoot, finalDirectory))
|
||||
return Error(TB("The resolved plugin directory is outside the plugin directory."));
|
||||
|
||||
var replacementIssue = GetReplacementIssue(plugin.Id, pluginType);
|
||||
if (!string.IsNullOrWhiteSpace(replacementIssue))
|
||||
return Error(replacementIssue);
|
||||
|
||||
if (Directory.Exists(finalDirectory))
|
||||
{
|
||||
replacedExisting = true;
|
||||
|
||||
// The backup goes to a directory outside the plugin root, so the plugin loader
|
||||
// cannot discover it during the reload below. Otherwise, the previous version
|
||||
// would be loaded a second time, next to the version we are installing:
|
||||
backupDirectory = CreateInstallBackupDirectory(plugin);
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(backupDirectory)!);
|
||||
Directory.Move(finalDirectory, backupDirectory);
|
||||
}
|
||||
|
||||
Directory.Move(stagingDirectory, finalDirectory);
|
||||
movedIntoPlace = true;
|
||||
await PluginFactory.LoadAll(token);
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(backupDirectory))
|
||||
TryDeleteDirectory(backupDirectory, "plugin backup", this.logger);
|
||||
|
||||
this.logger.LogInformation("Installed plugin '{PluginName}' ({PluginId}, {PluginType}) to '{PluginDirectory}'.", plugin.Name, plugin.Id, pluginType, finalDirectory);
|
||||
return new(true, plugin.Id, plugin.Name, finalDirectory, replacedExisting, string.Empty);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
this.logger.LogError(e, "Failed to install plugin.");
|
||||
|
||||
// Only remove the target directory when this installation actually moved the plugin
|
||||
// there. Otherwise, when moving the previous plugin into the backup directory failed,
|
||||
// we would delete the still intact previous plugin:
|
||||
if (movedIntoPlace && !string.IsNullOrWhiteSpace(finalDirectory) && Directory.Exists(finalDirectory))
|
||||
TryDeleteDirectory(finalDirectory, "failed assistant plugin installation", this.logger);
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(backupDirectory) && Directory.Exists(backupDirectory) && !string.IsNullOrWhiteSpace(finalDirectory) && !Directory.Exists(finalDirectory))
|
||||
{
|
||||
try
|
||||
{
|
||||
Directory.Move(backupDirectory, finalDirectory);
|
||||
await PluginFactory.LoadAll(CancellationToken.None);
|
||||
}
|
||||
catch (Exception restoreException)
|
||||
{
|
||||
this.logger.LogError(restoreException, "Failed to restore the previous assistant plugin after a failed installation.");
|
||||
}
|
||||
}
|
||||
|
||||
return Error(string.Format(TB("Unexpected error: {0}"), e.Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.TryDeleteStagingDirectory(stagingDirectory);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Loads and validates plugin code that is not installed yet.
|
||||
/// </summary>
|
||||
/// <param name="pluginDirectory">The staging directory the plugin currently lives in.</param>
|
||||
/// <param name="pluginCode">The <c>plugin.lua</c> content to validate.</param>
|
||||
/// <param name="expectedType">The plugin type the caller accepts.</param>
|
||||
/// <param name="wrongTypeIssue">Issue when the plugin has another type. Gets the plugin issues as {0}.</param>
|
||||
/// <param name="invalidPluginIssue">Issue when the plugin is of the right type, but invalid. Gets the plugin issues as {0}.</param>
|
||||
/// <param name="conflictingPluginIdIssue">Issue when another plugin already uses this plugin ID.</param>
|
||||
/// <param name="token">Cancellation token for running the Lua code.</param>
|
||||
/// <returns>The validation result, including the loaded plugin when it passed.</returns>
|
||||
private static async Task<PluginValidationResult> ValidatePluginCodeAsync(string pluginDirectory, string pluginCode, PluginType expectedType,
|
||||
string wrongTypeIssue, string invalidPluginIssue, string conflictingPluginIdIssue, CancellationToken token)
|
||||
{
|
||||
// The plugin is not installed yet: it sits in a staging directory outside the installed
|
||||
// plugins directory. We allow that directory as the module base, so the plugin can load its
|
||||
// own Lua modules, e.g., an icon.lua, while we validate it:
|
||||
var plugin = await PluginFactory.Load(pluginDirectory, pluginCode, token, pluginDirectory);
|
||||
if (plugin.Type != expectedType)
|
||||
return PluginValidationResult.Failure(string.Format(wrongTypeIssue, string.Join("; ", plugin.Issues)));
|
||||
|
||||
if (!plugin.IsValid)
|
||||
return PluginValidationResult.Failure(string.Format(invalidPluginIssue, string.Join("; ", plugin.Issues)));
|
||||
|
||||
// Plugin IDs must be unique across all plugin types: several lookups resolve a plugin by its
|
||||
// ID alone, e.g., the base language plugin in PluginFactory.Starting. A plugin carrying the
|
||||
// ID of a plugin of another type would break those lookups. Reusing the ID of another local
|
||||
// plugin of the same type stays allowed: that is how updating one works.
|
||||
if (PluginFactory.AvailablePlugins.Any(availablePlugin => availablePlugin.Id == plugin.Id && (availablePlugin.IsInternal || availablePlugin.Type != expectedType)))
|
||||
return PluginValidationResult.Failure(conflictingPluginIdIssue);
|
||||
|
||||
return new(true, string.Empty, plugin, string.Empty);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Determines the directory local plugins of the given type are installed into.
|
||||
/// </summary>
|
||||
private static bool TryGetPluginRoot(PluginType pluginType, out string pluginRoot, out string issue)
|
||||
{
|
||||
pluginRoot = string.Empty;
|
||||
issue = string.Empty;
|
||||
|
||||
var dataDirectory = SettingsManager.DataDirectory;
|
||||
if (string.IsNullOrWhiteSpace(dataDirectory))
|
||||
{
|
||||
issue = TB("The AI Studio data directory is not initialized yet.");
|
||||
return false;
|
||||
}
|
||||
|
||||
pluginRoot = Path.Join(dataDirectory, "plugins", pluginType.GetDirectory());
|
||||
return true;
|
||||
}
|
||||
|
||||
private static string DetermineFinalDirectory(string pluginRoot, IPluginMetadata plugin, PluginType pluginType)
|
||||
{
|
||||
var existingPlugin = FindReplaceablePlugin(plugin.Id, pluginType);
|
||||
return existingPlugin is not null
|
||||
? existingPlugin.LocalPath
|
||||
: Path.Join(pluginRoot, CreatePluginDirectoryName(plugin));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Finds the local plugin that an installation with the given ID and type would replace.
|
||||
/// </summary>
|
||||
/// <param name="pluginId">The ID of the plugin about to be installed.</param>
|
||||
/// <param name="pluginType">The type of the plugin about to be installed.</param>
|
||||
/// <returns>The plugin that would be replaced, or null when the installation adds a new plugin.</returns>
|
||||
private static IAvailablePlugin? FindReplaceablePlugin(Guid pluginId, PluginType pluginType) => PluginFactory.AvailablePlugins
|
||||
.OfType<IAvailablePlugin>()
|
||||
.FirstOrDefault(plugin => plugin.Type == pluginType && plugin.Id == pluginId && !plugin.IsInternal);
|
||||
|
||||
/// <summary>
|
||||
/// Collects the metadata an archive declares about itself, together with the information about
|
||||
/// the installed plugin it would replace.
|
||||
/// </summary>
|
||||
/// <param name="plugin">The validated plugin from the archive.</param>
|
||||
/// <returns>The preview shown to the user before the installation starts.</returns>
|
||||
private static PluginImportPreview CreateImportPreview(PluginBase plugin) => new(plugin, FindReplaceablePlugin(plugin.Id, plugin.Type));
|
||||
|
||||
/// <summary>
|
||||
/// Checks whether an installation may replace the plugin that currently uses the given ID.
|
||||
/// Plugins deployed by a Config Server belong to the organization's IT, so neither an import nor
|
||||
/// the Assistant Builder may overwrite them.
|
||||
/// </summary>
|
||||
/// <param name="pluginId">The ID of the plugin about to be installed.</param>
|
||||
/// <param name="pluginType">The type of the plugin about to be installed.</param>
|
||||
/// <returns>A user-facing issue when the existing plugin must not be replaced, an empty string otherwise.</returns>
|
||||
private static string GetReplacementIssue(Guid pluginId, PluginType pluginType)
|
||||
{
|
||||
var existingPlugin = FindReplaceablePlugin(pluginId, pluginType);
|
||||
if (existingPlugin is null)
|
||||
return string.Empty;
|
||||
|
||||
if (existingPlugin.IsManagedByConfigServer)
|
||||
return TB("Plugins deployed by your organization cannot be replaced.");
|
||||
|
||||
if (string.IsNullOrWhiteSpace(existingPlugin.LocalPath))
|
||||
return string.Empty;
|
||||
|
||||
// The metadata above and the running plugin read the same Lua field. We check both, though,
|
||||
// just like the deletion path does:
|
||||
var runningPlugin = PluginFactory.RunningPlugins
|
||||
.FirstOrDefault(candidate => candidate.Id == pluginId && IsSameDirectory(candidate.PluginPath, existingPlugin.LocalPath));
|
||||
|
||||
var isManagedByConfigServer = runningPlugin switch
|
||||
{
|
||||
PluginAssistants assistantPlugin => assistantPlugin.IsManagedByConfigServer,
|
||||
PluginConfiguration configurationPlugin => configurationPlugin.DeployedUsingConfigServer ?? false,
|
||||
|
||||
_ => false,
|
||||
};
|
||||
|
||||
return isManagedByConfigServer
|
||||
? TB("Plugins deployed by your organization cannot be replaced.")
|
||||
: string.Empty;
|
||||
}
|
||||
|
||||
private static string CreateInstallBackupDirectory(IPluginMetadata plugin)
|
||||
{
|
||||
var backupRoot = Path.Join(SettingsManager.DataDirectory, INSTALL_BACKUP_DIRECTORY);
|
||||
return Path.Join(backupRoot, $"assistant-{plugin.Id:N}-{Guid.NewGuid():N}");
|
||||
}
|
||||
|
||||
private static string CreatePluginDirectoryName(IPluginMetadata plugin)
|
||||
{
|
||||
var safeName = CreateSafeDirectoryNamePart(plugin.Name);
|
||||
return $"{safeName}-{plugin.Id:N}";
|
||||
}
|
||||
|
||||
private static string CreateSafeDirectoryNamePart(string name)
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
var invalidChars = Path.GetInvalidFileNameChars().ToHashSet();
|
||||
|
||||
foreach (var character in name.Trim())
|
||||
{
|
||||
if (char.IsLetterOrDigit(character))
|
||||
{
|
||||
sb.Append(char.ToLowerInvariant(character));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (character is '-' or '_' or '.' && !invalidChars.Contains(character))
|
||||
{
|
||||
sb.Append(character);
|
||||
continue;
|
||||
}
|
||||
|
||||
AppendSeparator();
|
||||
}
|
||||
|
||||
var safeName = sb.ToString().Trim('-', '.');
|
||||
if (safeName.Length > DIRECTORY_PREFIX_MAX_LEN)
|
||||
safeName = safeName[..DIRECTORY_PREFIX_MAX_LEN].Trim('-', '.');
|
||||
|
||||
// Fallback for a plugin name without any usable character. The plugin ID is appended by the
|
||||
// caller, so the directory stays unique either way:
|
||||
return string.IsNullOrWhiteSpace(safeName)
|
||||
? "plugin"
|
||||
: safeName;
|
||||
|
||||
void AppendSeparator()
|
||||
{
|
||||
if (sb.Length == 0 || sb[^1] == '-')
|
||||
return;
|
||||
|
||||
sb.Append('-');
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user