834 lines
33 KiB
C#
834 lines
33 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Diagnostics;
|
|
using System.IO.Pipes;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using Microsoft.UI.Xaml;
|
|
using Microsoft.UI.Xaml.Controls;
|
|
using Windows.ApplicationModel.DataTransfer;
|
|
using Windows.Storage;
|
|
using Windows.Storage.Pickers;
|
|
using Windows.System;
|
|
using WinRT.Interop;
|
|
using YMhut.Box.Core.App;
|
|
using YMhut.Box.Core.Logging;
|
|
using YMhut.Box.Core.Platform;
|
|
using YMhut.Box.Core.Plugins;
|
|
using YMhut.Box.Core.Plugins.Runtime;
|
|
using YMhut.Box.Core.Settings;
|
|
using YMhut.Box.Core.Tools;
|
|
|
|
namespace YMhut.Box.WinUI.Services;
|
|
|
|
public sealed class TauriPluginProcessService(
|
|
AppPaths paths,
|
|
IPluginHostProcessService pluginHost,
|
|
IToolLinkNavigationService linkNavigationService,
|
|
ISettingsService settingsService,
|
|
ILogService? logService = null) : IPluginRuntimeLauncher, IDisposable
|
|
{
|
|
private static readonly TimeSpan BrokerConnectTimeout = TimeSpan.FromSeconds(12);
|
|
private readonly ConcurrentDictionary<string, PluginRuntimeSession> _sessions = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly ConcurrentDictionary<string, Process> _processes = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly ConcurrentDictionary<string, List<ShellOutputEvent>> _output = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly ConcurrentDictionary<string, ExternalRuntimeBroker> _brokers = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly ConcurrentDictionary<string, string> _externalOutputs = new(StringComparer.OrdinalIgnoreCase);
|
|
private long _sequence;
|
|
private int _snapshotSubscribed;
|
|
private bool _disposed;
|
|
|
|
public async Task<PluginRuntimeSession> LaunchAsync(PluginRuntimeLaunchRequest request, CancellationToken cancellationToken = default)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var sessionId = Guid.NewGuid().ToString("N");
|
|
var startedAt = DateTimeOffset.Now;
|
|
var host = ResolveHostExecutable();
|
|
var session = new PluginRuntimeSession(
|
|
sessionId,
|
|
request.PluginId,
|
|
request.SurfaceId,
|
|
request.RuntimeKind,
|
|
null,
|
|
PluginRuntimeSessionStatus.Starting,
|
|
startedAt);
|
|
|
|
_sessions[sessionId] = session;
|
|
_output[sessionId] = [];
|
|
|
|
if (host is null)
|
|
{
|
|
session = session with
|
|
{
|
|
Status = PluginRuntimeSessionStatus.Failed,
|
|
EndedAt = DateTimeOffset.Now,
|
|
LastError = "Tauri plugin host executable was not found."
|
|
};
|
|
_sessions[sessionId] = session;
|
|
await WriteLogAsync("Error", request.PluginId, "Tauri plugin host missing", session.LastError, cancellationToken).ConfigureAwait(false);
|
|
return session;
|
|
}
|
|
|
|
ExternalRuntimeBroker? broker = null;
|
|
Process? process = null;
|
|
|
|
try
|
|
{
|
|
EnsureSnapshotSubscription();
|
|
if (!settingsService.Current.PluginDeveloperMode)
|
|
{
|
|
throw new UnauthorizedAccessException("The controlled external runtime requires plugin developer mode.");
|
|
}
|
|
var snapshot = await pluginHost.GetSnapshotAsync(cancellationToken).ConfigureAwait(false);
|
|
var pluginDto = snapshot.Plugins.FirstOrDefault(candidate =>
|
|
string.Equals(candidate.Manifest.Id, request.PluginId, StringComparison.OrdinalIgnoreCase));
|
|
if (pluginDto is null || !pluginDto.IsValid || !pluginDto.State.Enabled ||
|
|
pluginDto.Manifest.Runtime != PluginRuntimeKind.Tauri)
|
|
{
|
|
throw new UnauthorizedAccessException("The Tauri plugin is unavailable, disabled, or invalid.");
|
|
}
|
|
|
|
var plugin = pluginDto.ToLoadedPlugin();
|
|
if (!PluginPermissionPolicy.IsGrantCurrent(plugin.Manifest, plugin.State, PluginPermission.ExternalRuntime) ||
|
|
!string.Equals(plugin.State.ExternalRuntimeConfirmation, plugin.Manifest.Version, StringComparison.Ordinal))
|
|
{
|
|
throw new UnauthorizedAccessException("The external runtime permission or version confirmation is not current.");
|
|
}
|
|
|
|
var registeredRoot = Path.GetFullPath(plugin.RootPath);
|
|
var requestedRoot = Path.GetFullPath(request.PluginRoot);
|
|
var requestedEntry = Path.GetFullPath(request.Entry);
|
|
if (!string.Equals(registeredRoot.TrimEnd(Path.DirectorySeparatorChar), requestedRoot.TrimEnd(Path.DirectorySeparatorChar), StringComparison.OrdinalIgnoreCase) ||
|
|
!PluginRegistryService.IsInside(registeredRoot, requestedEntry) ||
|
|
!File.Exists(requestedEntry))
|
|
{
|
|
throw new InvalidDataException("The external runtime launch paths do not match the registered plugin package.");
|
|
}
|
|
|
|
var allowedOrigins = await ResolveAllowedOriginsAsync(plugin, cancellationToken).ConfigureAwait(false);
|
|
var origin = PluginExternalWebOrigin.Create(request.PluginId, request.SurfaceId);
|
|
var protocolName = PluginExternalWebOrigin.ProtocolName(request.PluginId, request.SurfaceId);
|
|
var bridgeSessionToken = await pluginHost.OpenBridgeSessionAsync(
|
|
request.PluginId,
|
|
request.SurfaceId,
|
|
origin,
|
|
cancellationToken).ConfigureAwait(false);
|
|
var pipeName = $"YMhutBoxExternalPlugin-{Environment.ProcessId}-{Guid.NewGuid():N}";
|
|
var pipe = new NamedPipeServerStream(
|
|
pipeName,
|
|
PipeDirection.InOut,
|
|
1,
|
|
PipeTransmissionMode.Byte,
|
|
PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly);
|
|
broker = new ExternalRuntimeBroker(
|
|
sessionId,
|
|
request.PluginId,
|
|
request.SurfaceId,
|
|
origin,
|
|
bridgeSessionToken,
|
|
RuntimePolicyKey(plugin),
|
|
pipe);
|
|
_brokers[sessionId] = broker;
|
|
|
|
var profileRoot = Path.Combine(paths.Cache, "WebView2", "Plugins", request.PluginId, "Tauri", request.SurfaceId);
|
|
Directory.CreateDirectory(profileRoot);
|
|
var startInfo = new ProcessStartInfo
|
|
{
|
|
FileName = host,
|
|
WorkingDirectory = Path.GetDirectoryName(host) ?? AppContext.BaseDirectory,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
CreateNoWindow = false
|
|
};
|
|
|
|
AddArgument(startInfo, "--session", sessionId);
|
|
AddArgument(startInfo, "--plugin-id", request.PluginId);
|
|
AddArgument(startInfo, "--surface-id", request.SurfaceId);
|
|
AddArgument(startInfo, "--runtime-kind", request.RuntimeKind.ToString());
|
|
AddArgument(startInfo, "--plugin-root", registeredRoot);
|
|
AddArgument(startInfo, "--entry", requestedEntry);
|
|
AddArgument(startInfo, "--protocol-name", protocolName);
|
|
AddArgument(startInfo, "--plugin-origin", origin);
|
|
AddArgument(startInfo, "--profile-root", profileRoot);
|
|
AddArgument(startInfo, "--broker-pipe", pipeName);
|
|
AddArgument(startInfo, "--developer-mode", settingsService.Current.PluginDeveloperMode ? "true" : "false");
|
|
foreach (var allowedOrigin in allowedOrigins)
|
|
{
|
|
AddArgument(startInfo, "--allowed-origin", allowedOrigin);
|
|
}
|
|
|
|
process = Process.Start(startInfo) ?? throw new InvalidOperationException("Unable to start Tauri plugin host.");
|
|
process.EnableRaisingEvents = true;
|
|
process.OutputDataReceived += (_, args) => CaptureOutput(sessionId, ShellOutputStream.Stdout, args.Data);
|
|
process.ErrorDataReceived += (_, args) => CaptureOutput(sessionId, ShellOutputStream.Stderr, args.Data);
|
|
process.Exited += (_, _) => CompleteSession(sessionId, process);
|
|
process.BeginOutputReadLine();
|
|
process.BeginErrorReadLine();
|
|
_processes[sessionId] = process;
|
|
|
|
await pipe.WaitForConnectionAsync(cancellationToken)
|
|
.WaitAsync(BrokerConnectTimeout, cancellationToken)
|
|
.ConfigureAwait(false);
|
|
broker.Reader = new StreamReader(pipe, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 4096, leaveOpen: true);
|
|
broker.Writer = new StreamWriter(pipe, new UTF8Encoding(false), bufferSize: 4096, leaveOpen: true) { AutoFlush = true };
|
|
await broker.Writer.WriteLineAsync(PluginRuntimeProtocol.Serialize(new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.Ready,
|
|
Version: PluginRuntimeProtocol.Version,
|
|
SessionToken: bridgeSessionToken,
|
|
Origin: origin))).ConfigureAwait(false);
|
|
broker.LoopTask = Task.Run(() => RunBrokerAsync(broker), CancellationToken.None);
|
|
|
|
session = session with
|
|
{
|
|
ProcessId = process.Id,
|
|
Status = PluginRuntimeSessionStatus.Running
|
|
};
|
|
_sessions[sessionId] = session;
|
|
await WriteLogAsync("Information", request.PluginId, "Tauri plugin host launched", $"session={sessionId}; pid={process.Id}", cancellationToken).ConfigureAwait(false);
|
|
return session;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (process is { HasExited: false })
|
|
{
|
|
try
|
|
{
|
|
process.Kill(entireProcessTree: true);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
if (broker is not null)
|
|
{
|
|
await CloseBrokerAsync(sessionId, broker).ConfigureAwait(false);
|
|
}
|
|
session = session with
|
|
{
|
|
Status = PluginRuntimeSessionStatus.Failed,
|
|
EndedAt = DateTimeOffset.Now,
|
|
LastError = exception.Message
|
|
};
|
|
_sessions[sessionId] = session;
|
|
await WriteLogAsync("Error", request.PluginId, "Tauri plugin host launch failed", exception.Message, cancellationToken).ConfigureAwait(false);
|
|
return session;
|
|
}
|
|
}
|
|
|
|
public async Task StopAsync(string sessionId, CancellationToken cancellationToken = default)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
if (_brokers.TryGetValue(sessionId, out var broker))
|
|
{
|
|
await CloseBrokerAsync(sessionId, broker).ConfigureAwait(false);
|
|
}
|
|
if (_processes.TryRemove(sessionId, out var process))
|
|
{
|
|
try
|
|
{
|
|
if (!process.HasExited)
|
|
{
|
|
process.Kill(entireProcessTree: true);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
CaptureOutput(sessionId, ShellOutputStream.System, $"Stop failed: {exception.Message}");
|
|
}
|
|
finally
|
|
{
|
|
process.Dispose();
|
|
}
|
|
}
|
|
|
|
if (_sessions.TryGetValue(sessionId, out var session))
|
|
{
|
|
_sessions[sessionId] = session with
|
|
{
|
|
Status = PluginRuntimeSessionStatus.Cancelled,
|
|
EndedAt = DateTimeOffset.Now
|
|
};
|
|
await WriteLogAsync("Information", session.PluginId, "Tauri plugin host stopped", $"session={sessionId}", cancellationToken).ConfigureAwait(false);
|
|
}
|
|
_externalOutputs.TryRemove(sessionId, out _);
|
|
}
|
|
|
|
public Task<PluginRuntimeSession?> GetSessionAsync(string sessionId, CancellationToken cancellationToken = default)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
_sessions.TryGetValue(sessionId, out var session);
|
|
return Task.FromResult(session);
|
|
}
|
|
|
|
public Task<IReadOnlyList<ShellOutputEvent>> ReadRecentOutputAsync(string sessionId, int take = 200, CancellationToken cancellationToken = default)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
if (!_output.TryGetValue(sessionId, out var lines))
|
|
{
|
|
return Task.FromResult<IReadOnlyList<ShellOutputEvent>>([]);
|
|
}
|
|
|
|
lock (lines)
|
|
{
|
|
return Task.FromResult<IReadOnlyList<ShellOutputEvent>>(lines.TakeLast(Math.Max(0, take)).ToArray());
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_disposed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_disposed = true;
|
|
if (Interlocked.Exchange(ref _snapshotSubscribed, 0) != 0)
|
|
{
|
|
pluginHost.SnapshotChanged -= PluginHost_SnapshotChanged;
|
|
}
|
|
foreach (var sessionId in _processes.Keys.ToArray())
|
|
{
|
|
try
|
|
{
|
|
StopAsync(sessionId).GetAwaiter().GetResult();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CompleteSession(string sessionId, Process process)
|
|
{
|
|
try
|
|
{
|
|
if (_brokers.TryGetValue(sessionId, out var broker))
|
|
{
|
|
_ = CloseBrokerAsync(sessionId, broker);
|
|
}
|
|
_externalOutputs.TryRemove(sessionId, out _);
|
|
int? exitCode = process.HasExited ? process.ExitCode : null;
|
|
if (_sessions.TryGetValue(sessionId, out var session))
|
|
{
|
|
_sessions[sessionId] = session with
|
|
{
|
|
Status = exitCode == 0 ? PluginRuntimeSessionStatus.Exited : PluginRuntimeSessionStatus.Failed,
|
|
EndedAt = DateTimeOffset.Now,
|
|
ExitCode = exitCode
|
|
};
|
|
_ = WriteLogAsync(
|
|
exitCode == 0 ? "Information" : "Error",
|
|
session.PluginId,
|
|
"Tauri plugin host exited",
|
|
$"session={sessionId}; exitCode={exitCode}",
|
|
CancellationToken.None);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_processes.TryRemove(sessionId, out _);
|
|
process.Dispose();
|
|
}
|
|
}
|
|
|
|
private void CaptureOutput(string sessionId, ShellOutputStream stream, string? line)
|
|
{
|
|
if (line is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var output = new ShellOutputEvent(sessionId, stream, line, DateTimeOffset.Now, Interlocked.Increment(ref _sequence));
|
|
var lines = _output.GetOrAdd(sessionId, _ => []);
|
|
lock (lines)
|
|
{
|
|
lines.Add(output);
|
|
if (lines.Count > 5000)
|
|
{
|
|
lines.RemoveRange(0, lines.Count - 5000);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task WriteLogAsync(string level, string pluginId, string message, string? detail, CancellationToken cancellationToken)
|
|
{
|
|
await (logService?.WriteAsync(level, $"plugin:{pluginId}:runtime", message, detail, cancellationToken) ?? Task.CompletedTask).ConfigureAwait(false);
|
|
}
|
|
|
|
private async Task<IReadOnlyList<string>> ResolveAllowedOriginsAsync(LoadedPlugin plugin, CancellationToken cancellationToken)
|
|
{
|
|
if (!PluginPermissionPolicy.IsGrantCurrent(plugin.Manifest, plugin.State, PluginPermission.Http))
|
|
{
|
|
return [];
|
|
}
|
|
|
|
var origins = new List<string>();
|
|
foreach (var value in plugin.Manifest.Network?.AllowedOrigins ?? [])
|
|
{
|
|
if (!PluginNetworkPolicy.TryNormalizePublicOrigin(value, allowWebSocket: true, out var origin) ||
|
|
!Uri.TryCreate(origin, UriKind.Absolute, out var uri) ||
|
|
!await PluginNetworkPolicy.ResolvesToPublicAddressAsync(uri.Host, cancellationToken).ConfigureAwait(false))
|
|
{
|
|
throw new UnauthorizedAccessException("A declared external runtime origin did not resolve exclusively to public addresses.");
|
|
}
|
|
origins.Add(origin);
|
|
}
|
|
return origins.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
|
|
}
|
|
|
|
private void EnsureSnapshotSubscription()
|
|
{
|
|
if (Interlocked.Exchange(ref _snapshotSubscribed, 1) == 0)
|
|
{
|
|
pluginHost.SnapshotChanged += PluginHost_SnapshotChanged;
|
|
}
|
|
}
|
|
|
|
private void PluginHost_SnapshotChanged(object? sender, PluginSnapshot snapshot)
|
|
{
|
|
foreach (var broker in _brokers.Values)
|
|
{
|
|
var plugin = snapshot.Plugins.FirstOrDefault(candidate =>
|
|
string.Equals(candidate.Manifest.Id, broker.PluginId, StringComparison.OrdinalIgnoreCase));
|
|
if (plugin is null || !plugin.IsValid || RuntimePolicyKey(plugin.ToLoadedPlugin()) != broker.PolicyKey)
|
|
{
|
|
_ = StopAsync(broker.SessionId);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string RuntimePolicyKey(LoadedPlugin plugin)
|
|
{
|
|
var state = plugin.State;
|
|
return JsonSerializer.Serialize(new
|
|
{
|
|
plugin.Manifest.Version,
|
|
plugin.Manifest.Runtime,
|
|
plugin.Manifest.Permissions,
|
|
plugin.Manifest.Security,
|
|
plugin.Manifest.PermissionReasons,
|
|
plugin.Manifest.Network,
|
|
plugin.Manifest.Requirements,
|
|
state.Enabled,
|
|
Granted = state.GrantedPermissions.OrderBy(value => value).ToArray(),
|
|
Fingerprints = state.PermissionPolicyFingerprints?.OrderBy(value => value.Key).ToArray(),
|
|
state.ExternalRuntimeConfirmation
|
|
});
|
|
}
|
|
|
|
private async Task RunBrokerAsync(ExternalRuntimeBroker broker)
|
|
{
|
|
try
|
|
{
|
|
while (!broker.Cancellation.IsCancellationRequested && broker.Reader is not null)
|
|
{
|
|
var line = await broker.Reader.ReadLineAsync(broker.Cancellation.Token).ConfigureAwait(false);
|
|
if (line is null)
|
|
{
|
|
break;
|
|
}
|
|
if (Encoding.UTF8.GetByteCount(line) > 512 * 1024)
|
|
{
|
|
await WriteBrokerResponseAsync(broker, new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.Error,
|
|
Error: "External runtime message exceeded the size limit.")).ConfigureAwait(false);
|
|
break;
|
|
}
|
|
|
|
PluginRuntimeMessage? message;
|
|
try
|
|
{
|
|
message = PluginRuntimeProtocol.Deserialize(line);
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
message = null;
|
|
}
|
|
|
|
if (message is null)
|
|
{
|
|
await WriteBrokerResponseAsync(broker, new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.Error,
|
|
Error: "External runtime sent an invalid message.")).ConfigureAwait(false);
|
|
continue;
|
|
}
|
|
|
|
if (string.Equals(message.Type, PluginRuntimeProtocol.Ping, StringComparison.Ordinal))
|
|
{
|
|
await WriteBrokerResponseAsync(broker, new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.Pong,
|
|
message.RequestId,
|
|
Version: PluginRuntimeProtocol.Version)).ConfigureAwait(false);
|
|
continue;
|
|
}
|
|
|
|
if (!string.Equals(message.Type, PluginRuntimeProtocol.BridgeCall, StringComparison.Ordinal) ||
|
|
message.BridgeRequest is null)
|
|
{
|
|
await WriteBrokerResponseAsync(broker, new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.Error,
|
|
message.RequestId,
|
|
Error: "External runtime message type is not supported.")).ConfigureAwait(false);
|
|
continue;
|
|
}
|
|
|
|
var response = await HandleBrokerBridgeCallAsync(broker, message.BridgeRequest).ConfigureAwait(false);
|
|
await WriteBrokerResponseAsync(broker, new PluginRuntimeMessage(
|
|
PluginRuntimeProtocol.BridgeCall,
|
|
message.RequestId,
|
|
BridgeResponse: response)).ConfigureAwait(false);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
CaptureOutput(broker.SessionId, ShellOutputStream.System, "External runtime broker stopped unexpectedly.");
|
|
await WriteLogAsync(
|
|
"Warning",
|
|
broker.PluginId,
|
|
"External runtime broker failed",
|
|
AppLocalizer.SanitizeSensitiveText(exception.Message, 220),
|
|
CancellationToken.None).ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
await CloseBrokerAsync(broker.SessionId, broker).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
private async Task<PluginBridgeResponse> HandleBrokerBridgeCallAsync(ExternalRuntimeBroker broker, PluginBridgeRequest request)
|
|
{
|
|
if (!string.Equals(request.PluginId, broker.PluginId, StringComparison.OrdinalIgnoreCase) ||
|
|
!string.Equals(request.SurfaceId, broker.SurfaceId, StringComparison.OrdinalIgnoreCase) ||
|
|
!string.Equals(request.SessionToken, broker.BridgeSessionToken, StringComparison.Ordinal) ||
|
|
!string.Equals(request.Origin, broker.Origin, StringComparison.OrdinalIgnoreCase) ||
|
|
Encoding.UTF8.GetByteCount(request.PayloadJson) > 256 * 1024)
|
|
{
|
|
return new PluginBridgeResponse(
|
|
false,
|
|
Error: "The external runtime bridge session is invalid.",
|
|
ErrorCode: PluginBridgeErrorCode.SessionInvalid);
|
|
}
|
|
|
|
var response = await pluginHost.BridgeCallAsync(request, broker.Cancellation.Token).ConfigureAwait(false);
|
|
if (!response.Ok)
|
|
{
|
|
return response;
|
|
}
|
|
|
|
try
|
|
{
|
|
using var document = JsonDocument.Parse(string.IsNullOrWhiteSpace(request.PayloadJson) ? "null" : request.PayloadJson);
|
|
var payload = document.RootElement.Clone();
|
|
var handled = false;
|
|
object? value = null;
|
|
if (response.UiAction is not null)
|
|
{
|
|
handled = true;
|
|
value = await ExecuteUiActionAsync(broker, response.UiAction, payload).ConfigureAwait(false);
|
|
}
|
|
else if (request.Method is "output.set" or "output.append" or "output.clear")
|
|
{
|
|
handled = true;
|
|
value = UpdateExternalOutput(broker.SessionId, request.Method, payload);
|
|
}
|
|
|
|
return handled
|
|
? response with { ValueJson = JsonSerializer.Serialize(value), UiAction = null }
|
|
: response with { UiAction = null };
|
|
}
|
|
catch (OperationCanceledException) when (broker.Cancellation.IsCancellationRequested)
|
|
{
|
|
return new PluginBridgeResponse(false, Error: "The external runtime session was closed.", ErrorCode: PluginBridgeErrorCode.SessionInvalid);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
await WriteLogAsync(
|
|
"Warning",
|
|
broker.PluginId,
|
|
"External runtime UI action failed",
|
|
AppLocalizer.SanitizeSensitiveText(exception.Message, 220),
|
|
CancellationToken.None).ConfigureAwait(false);
|
|
return new PluginBridgeResponse(false, Error: "The external runtime UI action failed.", ErrorCode: PluginBridgeErrorCode.HostFailure);
|
|
}
|
|
}
|
|
|
|
private Task<object?> ExecuteUiActionAsync(ExternalRuntimeBroker broker, string uiAction, JsonElement payload)
|
|
{
|
|
return RunOnUiThreadAsync<object?>(async () => uiAction switch
|
|
{
|
|
"clipboard.readText" => await ReadClipboardAsync().ConfigureAwait(true),
|
|
"clipboard.writeText" => WriteClipboard(payload),
|
|
"file.openPicker" => await OpenFilePickerAsync().ConfigureAwait(true),
|
|
"file.savePicker" => await SaveFilePickerAsync(payload).ConfigureAwait(true),
|
|
"openExternal" => await OpenExternalAsync(broker.PluginId, payload).ConfigureAwait(true),
|
|
_ => throw new NotSupportedException("The approved UI action is not supported by the external runtime broker.")
|
|
});
|
|
}
|
|
|
|
private object UpdateExternalOutput(string sessionId, string method, JsonElement payload)
|
|
{
|
|
if (method == "output.clear")
|
|
{
|
|
_externalOutputs.TryRemove(sessionId, out _);
|
|
CaptureOutput(sessionId, ShellOutputStream.System, "Plugin output cleared.");
|
|
return true;
|
|
}
|
|
|
|
var value = JsonValue(payload);
|
|
var next = method == "output.append" && _externalOutputs.TryGetValue(sessionId, out var current)
|
|
? current + value
|
|
: value;
|
|
if (next.Length > 256 * 1024)
|
|
{
|
|
next = next[(next.Length - (256 * 1024))..];
|
|
}
|
|
_externalOutputs[sessionId] = next;
|
|
CaptureOutput(sessionId, ShellOutputStream.System, $"Plugin output updated ({next.Length} chars).");
|
|
return true;
|
|
}
|
|
|
|
private static async Task<object?> ReadClipboardAsync()
|
|
{
|
|
var content = Clipboard.GetContent();
|
|
return content.Contains(StandardDataFormats.Text)
|
|
? await content.GetTextAsync().AsTask().ConfigureAwait(true)
|
|
: string.Empty;
|
|
}
|
|
|
|
private static object WriteClipboard(JsonElement payload)
|
|
{
|
|
var package = new DataPackage();
|
|
package.SetText(JsonValue(payload));
|
|
Clipboard.SetContent(package);
|
|
return true;
|
|
}
|
|
|
|
private static async Task<object?> OpenFilePickerAsync()
|
|
{
|
|
if (App.CurrentWindow is null)
|
|
{
|
|
throw new InvalidOperationException("No active window is available for the file picker.");
|
|
}
|
|
|
|
var picker = new FileOpenPicker();
|
|
InitializeWithWindow.Initialize(picker, WindowNative.GetWindowHandle(App.CurrentWindow));
|
|
picker.FileTypeFilter.Add("*");
|
|
var file = await picker.PickSingleFileAsync();
|
|
if (file is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var properties = await file.GetBasicPropertiesAsync();
|
|
if (properties.Size > 2 * 1024 * 1024)
|
|
{
|
|
throw new InvalidDataException("Selected plugin input files cannot exceed 2 MiB.");
|
|
}
|
|
|
|
return new { name = file.Name, content = await FileIO.ReadTextAsync(file) };
|
|
}
|
|
|
|
private static async Task<object?> SaveFilePickerAsync(JsonElement payload)
|
|
{
|
|
if (App.CurrentWindow is null)
|
|
{
|
|
throw new InvalidOperationException("No active window is available for the file picker.");
|
|
}
|
|
|
|
var suggestedName = ReadString(payload, "name") ?? "plugin-output.txt";
|
|
var value = ReadString(payload, "value") ?? ReadString(payload, "bytesOrText") ?? ReadString(payload, "text") ?? string.Empty;
|
|
var extension = Path.GetExtension(suggestedName);
|
|
if (string.IsNullOrWhiteSpace(extension))
|
|
{
|
|
extension = ".txt";
|
|
suggestedName += extension;
|
|
}
|
|
|
|
var picker = new FileSavePicker { SuggestedFileName = Path.GetFileNameWithoutExtension(suggestedName) };
|
|
InitializeWithWindow.Initialize(picker, WindowNative.GetWindowHandle(App.CurrentWindow));
|
|
picker.FileTypeChoices.Add("Plugin output", [extension]);
|
|
var file = await picker.PickSaveFileAsync();
|
|
if (file is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
await FileIO.WriteTextAsync(file, value);
|
|
return new { name = file.Name };
|
|
}
|
|
|
|
private async Task<object> OpenExternalAsync(string pluginId, JsonElement payload)
|
|
{
|
|
var value = ReadString(payload, "url") ?? JsonValue(payload);
|
|
var target = payload.ValueKind == JsonValueKind.Object && payload.TryGetProperty("options", out var options)
|
|
? ReadString(options, "target")
|
|
: null;
|
|
var linkTarget = string.Equals(target, "system", StringComparison.OrdinalIgnoreCase)
|
|
? ToolLinkTarget.SystemBrowser
|
|
: ToolLinkTarget.SafeBrowser;
|
|
if (linkTarget == ToolLinkTarget.SystemBrowser)
|
|
{
|
|
var root = App.CurrentWindow?.Content as FrameworkElement;
|
|
if (root?.XamlRoot is null)
|
|
{
|
|
throw new InvalidOperationException("No active window is available for confirmation.");
|
|
}
|
|
var dialog = new ContentDialog
|
|
{
|
|
Title = "允许插件打开系统浏览器？",
|
|
Content = $"插件 {pluginId} 请求打开：\n{value}",
|
|
PrimaryButtonText = "允许本次",
|
|
CloseButtonText = "取消",
|
|
DefaultButton = ContentDialogButton.Close,
|
|
XamlRoot = root.XamlRoot
|
|
};
|
|
if (await dialog.ShowAsync() != ContentDialogResult.Primary)
|
|
{
|
|
throw new UnauthorizedAccessException("The system browser request was cancelled.");
|
|
}
|
|
}
|
|
|
|
if (!await linkNavigationService.OpenAsync(value, linkTarget).ConfigureAwait(true))
|
|
{
|
|
throw new InvalidOperationException("The approved external link could not be opened.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static Task<T> RunOnUiThreadAsync<T>(Func<Task<T>> action)
|
|
{
|
|
var dispatcher = App.CurrentWindow?.DispatcherQueue
|
|
?? throw new InvalidOperationException("No active UI dispatcher is available.");
|
|
if (dispatcher.HasThreadAccess)
|
|
{
|
|
return action();
|
|
}
|
|
|
|
var completion = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
if (!dispatcher.TryEnqueue(async () =>
|
|
{
|
|
try
|
|
{
|
|
completion.TrySetResult(await action().ConfigureAwait(true));
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
completion.TrySetException(exception);
|
|
}
|
|
}))
|
|
{
|
|
completion.TrySetException(new InvalidOperationException("The UI dispatcher rejected the external runtime action."));
|
|
}
|
|
return completion.Task;
|
|
}
|
|
|
|
private static async Task WriteBrokerResponseAsync(ExternalRuntimeBroker broker, PluginRuntimeMessage message)
|
|
{
|
|
if (broker.Writer is null || broker.Cancellation.IsCancellationRequested)
|
|
{
|
|
return;
|
|
}
|
|
await broker.WriteGate.WaitAsync(broker.Cancellation.Token).ConfigureAwait(false);
|
|
try
|
|
{
|
|
await broker.Writer.WriteLineAsync(PluginRuntimeProtocol.Serialize(message)).ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
broker.WriteGate.Release();
|
|
}
|
|
}
|
|
|
|
private async Task CloseBrokerAsync(string sessionId, ExternalRuntimeBroker broker)
|
|
{
|
|
if (Interlocked.Exchange(ref broker.Closed, 1) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_brokers.TryRemove(sessionId, out _);
|
|
broker.Cancellation.Cancel();
|
|
try
|
|
{
|
|
broker.Reader?.Dispose();
|
|
broker.Writer?.Dispose();
|
|
broker.Pipe.Dispose();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
try
|
|
{
|
|
await pluginHost.CloseBridgeSessionAsync(broker.BridgeSessionToken).ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private static void AddArgument(ProcessStartInfo startInfo, string name, string value)
|
|
{
|
|
startInfo.ArgumentList.Add(name);
|
|
startInfo.ArgumentList.Add(value);
|
|
}
|
|
|
|
private static string JsonValue(JsonElement element)
|
|
{
|
|
return element.ValueKind == JsonValueKind.String ? element.GetString() ?? string.Empty : element.GetRawText();
|
|
}
|
|
|
|
private static string? ReadString(JsonElement element, string property)
|
|
{
|
|
return element.ValueKind == JsonValueKind.Object && element.TryGetProperty(property, out var value)
|
|
? JsonValue(value)
|
|
: null;
|
|
}
|
|
|
|
private string? ResolveHostExecutable()
|
|
{
|
|
var candidates = new List<string>
|
|
{
|
|
Path.Combine(AppContext.BaseDirectory, "tauri-host", "ymhut-box-plugin-tauri-host.exe"),
|
|
Path.Combine(AppContext.BaseDirectory, "tauri-host", "YMhut.Box.PluginTauriHost.exe"),
|
|
Path.Combine(paths.Root, "Runtime", "tauri-host", "ymhut-box-plugin-tauri-host.exe")
|
|
};
|
|
|
|
var directory = new DirectoryInfo(AppContext.BaseDirectory);
|
|
while (directory is not null)
|
|
{
|
|
candidates.Add(Path.Combine(directory.FullName, "src", "YMhut.Box.PluginTauriHost", "src-tauri", "target", "release", "ymhut-box-plugin-tauri-host.exe"));
|
|
candidates.Add(Path.Combine(directory.FullName, "src", "YMhut.Box.PluginTauriHost", "src-tauri", "target", "debug", "ymhut-box-plugin-tauri-host.exe"));
|
|
directory = directory.Parent;
|
|
}
|
|
|
|
return candidates.FirstOrDefault(File.Exists);
|
|
}
|
|
|
|
private sealed class ExternalRuntimeBroker(
|
|
string sessionId,
|
|
string pluginId,
|
|
string surfaceId,
|
|
string origin,
|
|
string bridgeSessionToken,
|
|
string policyKey,
|
|
NamedPipeServerStream pipe)
|
|
{
|
|
public string SessionId { get; } = sessionId;
|
|
public string PluginId { get; } = pluginId;
|
|
public string SurfaceId { get; } = surfaceId;
|
|
public string Origin { get; } = origin;
|
|
public string BridgeSessionToken { get; } = bridgeSessionToken;
|
|
public string PolicyKey { get; } = policyKey;
|
|
public NamedPipeServerStream Pipe { get; } = pipe;
|
|
public CancellationTokenSource Cancellation { get; } = new();
|
|
public SemaphoreSlim WriteGate { get; } = new(1, 1);
|
|
public StreamReader? Reader { get; set; }
|
|
public StreamWriter? Writer { get; set; }
|
|
public Task? LoopTask { get; set; }
|
|
public int Closed;
|
|
}
|
|
}
|