UI-Entwurf umgesetzt, Rocket.Chat-Tool, Deploymentcenter 2.4

Sicherungspunkt vor dem Aufraeumen. Buendelt die Arbeit, die seit dem
Abschluss der Avalonia-Portierung im Arbeitsverzeichnis lag.

Oberflaeche
- Entwurf aus Mockup/ umgesetzt: Theme.axaml (Farben je Thema, Barlow als
  mitgelieferte Schrift), Icons.axaml (Symbolgeometrien), Shell.axaml
  (eigene ControlThemes statt Fluent umzufaerben).
- Neue Steuerelemente StrokeIcon und BlueprintFrame, Seiten fuer
  Token-Verbrauch und Agenten-Chats, Werkzeug-Einstellungen als Seite
  statt eigenem Fenster, Texteditor-Fenster.
- ThemeManager mit hellem und dunklem Thema; die beiden Pinsel-Konverter
  entfallen, weil ein fester Farbwert den Themenwechsel nicht ueberlebt.

Rocket.Chat
- Neues Tool-Projekt (Client, Konfiguration, Workspace-Dateien) nach der
  Bauform des Telegram-Tools: rocketchat_poll als Tool-Job, geweckt wird
  nur, wenn wirklich etwas anliegt.
- send_file ist freigabepflichtig, send_message bewusst nicht: Der Raum
  ist Arbeitsraum, der Schutz sitzt an der Raum-Allowlist.
- Konzept-Doc um die Messung gegen die echte Instanz 8.7 ergaenzt; drei
  Annahmen waren falsch und sind korrigiert.

Deploymentcenter
- DC6 (Update anwenden) und DC7 (Erstinstallation ueber setup.json)
  erledigt, DC3 fuer win-x64/dev; deploy/publish.py als Release-Strecke.
- AppHost.DisposeAsync gegen doppeltes Herunterfahren gesperrt - sonst
  ueberschreibt eine zweite Abmeldung den Wartungszustand am Watchdog.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Richard
2026-08-23 12:16:05 +02:00
co-authored by Claude Opus 5
parent b5bf97ae74
commit 33d95a6c3f
88 changed files with 11665 additions and 1029 deletions
@@ -0,0 +1,150 @@
using System.Text.Json;
namespace ClawdDotNet.Tools.RocketChat;
/// <summary>
/// Die Tool-Konfiguration eines Agenten, aus dem freien Wörterbuch gelesen.
///
/// Die Werte kommen je nach Weg als <see cref="JsonElement"/> (frisch deserialisiert) oder
/// als einfache .NET-Werte (nach einer Bearbeitung in der Oberfläche) an — deshalb liest
/// jeder Zugriff über die Helfer unten, nie über eine direkte Umwandlung.
/// </summary>
internal sealed record RocketChatConfig(
string BaseUrl,
string UserId,
string AuthToken,
string? Username,
IReadOnlyList<string> AllowedRooms,
string? DefaultRoom,
bool MentionOnly,
IReadOnlyList<string> AgentUsernames,
int MaxWakesPerRoomPerHour,
int MaxMessagesPerRoom,
TimeSpan InitialLookback,
long MaxUploadBytes,
long MaxDownloadBytes,
bool AllowDangerousDownloads)
{
/// <summary>
/// Liest die Konfiguration. Gibt eine sprechende Fehlermeldung zurück, statt mit einer
/// Ausnahme zu scheitern — das Modell soll aus dem Ergebnis erkennen, was fehlt.
/// </summary>
public static (RocketChatConfig? Config, string? Error) Read(
IReadOnlyDictionary<string, object?> raw)
{
var baseUrl = GetString(raw, "baseUrl")?.TrimEnd('/');
if (string.IsNullOrWhiteSpace(baseUrl))
return (null, "Konfigurationsfehler: 'baseUrl' fehlt (z. B. \"https://chat.example.org\").");
if (!Uri.TryCreate(baseUrl, UriKind.Absolute, out var uri)
|| (uri.Scheme != Uri.UriSchemeHttps && uri.Scheme != Uri.UriSchemeHttp))
return (null, $"Konfigurationsfehler: 'baseUrl' ist keine gültige http(s)-Adresse: {baseUrl}");
var userId = GetString(raw, "userId");
if (string.IsNullOrWhiteSpace(userId))
return (null, "Konfigurationsfehler: 'userId' fehlt (die Rocket.Chat-Benutzer-Id dieses Agenten).");
var authToken = GetString(raw, "authToken");
if (string.IsNullOrWhiteSpace(authToken))
return (null, "Konfigurationsfehler: 'authToken' fehlt (Zugriffstoken des Agenten-Benutzers).");
return (new RocketChatConfig(
BaseUrl: baseUrl,
UserId: userId,
AuthToken: authToken,
Username: GetString(raw, "username"),
AllowedRooms: GetStringList(raw, "allowedRooms"),
DefaultRoom: GetString(raw, "defaultRoom"),
MentionOnly: GetBool(raw, "mentionOnly", defaultValue: true),
AgentUsernames: GetStringList(raw, "agentUsernames"),
MaxWakesPerRoomPerHour: GetInt(raw, "maxWakesPerRoomPerHour", defaultValue: 12),
MaxMessagesPerRoom: Math.Clamp(GetInt(raw, "maxMessagesPerRoom", defaultValue: 20), 1, 100),
InitialLookback: TimeSpan.FromMinutes(
Math.Clamp(GetInt(raw, "initialLookbackMinutes", defaultValue: 5), 1, 1440)),
MaxUploadBytes: Math.Clamp(
GetInt(raw, "maxUploadMb", defaultValue: 25), 1, 100) * 1024L * 1024L,
MaxDownloadBytes: Math.Clamp(
GetInt(raw, "maxDownloadMb", defaultValue: 25), 1, 100) * 1024L * 1024L,
AllowDangerousDownloads: GetBool(raw, "allowDangerousDownloads", defaultValue: false)),
null);
}
/// <summary>
/// Prüft, ob ein Raum benutzt werden darf. Eine leere Liste erlaubt jeden Raum — wer
/// keine Allowlist pflegt, hat sich dagegen entschieden; das Tool erfindet keine.
/// Verglichen wird gegen Raum-Id <b>und</b> Raumname, weil das Modell beides kennt.
/// </summary>
public bool IsRoomAllowed(string roomIdOrName)
{
if (AllowedRooms.Count == 0)
return true;
return AllowedRooms.Any(r =>
string.Equals(r, roomIdOrName, StringComparison.OrdinalIgnoreCase));
}
public bool IsAgentUser(string? username)
=> username is not null
&& AgentUsernames.Any(a => string.Equals(a, username, StringComparison.OrdinalIgnoreCase));
// ─── Lesehelfer für das freie Wörterbuch ───
private static string? GetString(IReadOnlyDictionary<string, object?> raw, string key)
=> raw.TryGetValue(key, out var v) ? AsString(v) : null;
private static string? AsString(object? value) => value switch
{
null => null,
string s => string.IsNullOrWhiteSpace(s) ? null : s,
JsonElement { ValueKind: JsonValueKind.String } je => je.GetString(),
JsonElement je => je.ToString(),
_ => value.ToString()
};
private static bool GetBool(IReadOnlyDictionary<string, object?> raw, string key, bool defaultValue)
{
if (!raw.TryGetValue(key, out var v) || v is null)
return defaultValue;
return v switch
{
bool b => b,
JsonElement { ValueKind: JsonValueKind.True } => true,
JsonElement { ValueKind: JsonValueKind.False } => false,
_ => bool.TryParse(AsString(v), out var parsed) ? parsed : defaultValue
};
}
private static int GetInt(IReadOnlyDictionary<string, object?> raw, string key, int defaultValue)
{
if (!raw.TryGetValue(key, out var v) || v is null)
return defaultValue;
return v switch
{
int i => i,
long l => (int)l,
JsonElement { ValueKind: JsonValueKind.Number } je when je.TryGetInt32(out var n) => n,
_ => int.TryParse(AsString(v), out var parsed) ? parsed : defaultValue
};
}
private static IReadOnlyList<string> GetStringList(
IReadOnlyDictionary<string, object?> raw, string key)
{
if (!raw.TryGetValue(key, out var v) || v is null)
return [];
return v switch
{
JsonElement { ValueKind: JsonValueKind.Array } je =>
je.EnumerateArray()
.Select(e => e.ValueKind == JsonValueKind.String ? e.GetString() : e.ToString())
.Where(s => !string.IsNullOrWhiteSpace(s))
.Select(s => s!)
.ToList(),
IEnumerable<string> list => list.Where(s => !string.IsNullOrWhiteSpace(s)).ToList(),
_ => AsString(v) is { } single ? [single] : []
};
}
}