diff --git a/.gitignore b/.gitignore index de97023..937864f 100644 --- a/.gitignore +++ b/.gitignore @@ -28,8 +28,8 @@ msbuild.wrn deploy/*.zip # ---- Runtime instance/agent data (created next to the binary) ---- -Instances/ -data/ +/Instances/ +/data/ # ---- OS files ---- Thumbs.db diff --git a/Directory.Build.props b/Directory.Build.props index 7c4f59e..d5bef64 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -34,6 +34,13 @@ Assemblies und nichts an Betriebsaufwand. --> embedded + + + de;en diff --git a/docs/Instanzmanager-Konzept.md b/docs/Instanzmanager-Konzept.md index 3a7fdf3..4d3e571 100644 --- a/docs/Instanzmanager-Konzept.md +++ b/docs/Instanzmanager-Konzept.md @@ -290,11 +290,9 @@ sondern die Prüfung aus E-M3. ja, aber nur, wenn die Instanz es verlangt. Der Schalter heißt „Autostart durch Manager" und steht in der Instanzdatei; siehe Abschnitt 9.7. -**Was ist mit einer Instanz, die verstummt?** Der Autostart greift nur bei einem -Absturz. Eine stumme Instanz lebt noch — sie neu zu starten hieße, sie erst -abzuschießen, und ob der Manager das von sich aus tun darf, ist nicht entschieden. -Bis dahin meldet er sie und lässt sie stehen. Genau dieser Zustand war der Anlass -(1.1), insofern ist die Frage nicht akademisch. +**Was ist mit einer Instanz, die verstummt? — Entschieden** (2026-09-10): Ja, der +Manager darf sie abschießen — aber erst am Ende einer Leiter, und nie ohne +Nachweis. Siehe Abschnitt 9.8. **Der Aufhänger aus 1.1 ist nicht geklärt** (#529). Er verschwindet mit dem Umbau vermutlich von selbst, weil es den Selbst-Neustart nicht mehr gibt — aber @@ -835,3 +833,84 @@ Diese drei Punkte sind **C#** und warten auf den Kern-Agenten. Nicht anfangen: 2. **Lizenzprüfung aus der Instanz nehmen** (E-M3 vollständig). Braucht vorher einen Handschlag, an dem eine Instanz erkennt, ob ein Manager da ist. 3. **Verstummte Instanzen neu starten?** Nicht entschieden — siehe Abschnitt 7. + +### 9.8 Geordnetes Ende und Puls + +Entschieden am 2026-09-10, aus zwei Befunden derselben Sitzung. + +**Der erste: Jedes Beenden war ein Abschneiden.** `TaskScanner.DisposeAsync` bricht den +laufenden Takt über sein Token ab — mitten in `ProcessAsync`, also *nachdem* eine Aufgabe +beansprucht wurde und *bevor* `CompleteClaimAsync` sie wieder freigibt. Sie steht danach +auf `running` und bleibt dort, bis das Lease abläuft. Ein Agentenlauf mitten im +Werkzeugaufruf verlor seine Antwort ganz. + +**Der zweite, schlimmere: Der Manager konnte eine Instanz mit Fenster überhaupt nicht +geordnet beenden.** `Control.ShutdownRequested` war nur kopflos verdrahtet +(`HeadlessRun`), nicht in der Avalonia-Anwendung — und ein Fenster ist die Vorgabe +(`InstanceWindows`). Die Bitte über den Socket wurde angenommen, mit 202 beantwortet, und +niemand hörte zu. Der Manager wartete seine Frist ab und schoss den Prozess dann **jedes +Mal** ab. Das geordnete Ende gab es auf dem Papier. + +#### Erst die Tür, dann warten + +`ShutdownCoordinator` (in `Core/Instances`) schließt zuerst alle Arbeitsquellen und wartet +danach, bis nichts mehr offen ist. Die Reihenfolge ist der ganze Trick: Andersherum +beansprucht der Scanner im nächsten Takt die nächste Aufgabe, und die Zahl der offenen +Arbeiten geht nie auf null. + +Zwei Quellen sind angemeldet — Agentenläufe und Aufgaben. Beide können genau zweierlei: +keine neue Arbeit mehr annehmen und sagen, wie viel noch läuft. Was daraus folgt, +entscheidet der Koordinator. Die Frist (zwei Minuten) ist eine Zusage, keine Hoffnung: +Danach endet die Instanz, ob fertig oder nicht — sonst hinge sie an einem Agentenlauf, der +auf ein Modell wartet, das nicht antwortet. Was dann noch offen war, steht im Protokoll. + +Beide Wege dorthin gibt es wirklich: Der Manager bittet über den Socket, und gleichzeitig +kann jemand am Fenster auf das Kreuz klicken. Ein zweiter Aufruf wartet deshalb auf +denselben Vorgang, statt einen neuen anzustoßen. + +#### Der Puls + +Der Manager fragte bisher `/api/info` und wusste danach nur, dass überhaupt jemand +geantwortet hat. Das reicht, um „läuft" von „tot" zu unterscheiden — aber nicht für die +beiden Fälle, die gleich aussehen und gegensätzlich zu behandeln sind: **eine Instanz, die +hängt, und eine, die gerade aufräumt.** Die erste gehört nach einer Frist abgeschossen, +die zweite in Ruhe gelassen. + +`GET /api/instanz/puls` liegt hinter dem Socket-Gate, gehört also dem Manager allein, und +nennt zusätzlich Phase und offene Arbeiten. Bewusst weiter **gefragt und nicht gemeldet**: +Ein Puls, den die Instanz von sich aus schickt, fehlt genau dann, wenn sie hängt — und +dann kann der Manager „hängt" nicht von „hat es vergessen" unterscheiden. Wer fragt, weiß, +wann er keine Antwort bekommen hat. + +#### Die Leiter + +| Stufe | Was passiert | +|---|---| +| 3 Durchgänge ohne Antwort | `Unresponsive`, gemeldet. Vorher nicht — ein Agentenlauf, der die Maschine auslastet, ist kein Vorfall | +| sofort danach | Einmal über den Socket um ein Ende bitten. **Ein Versuch, mehr nicht** — wer eben auf demselben Socket geschwiegen hat, hört wahrscheinlich auch das nicht. Es kann ein einzelner hängender Endpunkt sein und nicht der ganze Prozess; gewartet wird auf die Uhr, nicht auf die Antwort | +| nach 30 s (`silentKillGraceSeconds`) | Der Prozess wird beendet — und der Vollzug **abgewartet**. `Kill()` ist eine Bitte an das Betriebssystem, keine vollzogene Tatsache | +| danach | Gemeldet als **Absturz**, nicht als geordnetes Ende. Gewollt hat es niemand — und nur so greift der Autostart | +| vor jedem Start | `EnsureDeadAsync`: Antwortet noch jemand auf dem Socket? Lebt das Prozesshandle noch? Solange ja, wird **nicht** gestartet | + +Antwortet die Instanz zwischendurch wieder, war es ein Aussetzer, und niemand wird +abgeschossen (`Recovered`). + +#### Der Fehlschluss, der hier begraben liegt + +`StopAsync` brach seine Warteschleife ab, sobald der Socket nicht mehr antwortete, meldete +„beendet" und gab `true` zurück — **ohne den Prozess anzufassen.** Bei einer verstummten +Instanz ist der Socket aber von vornherein still: Der Aufruf meldete sofort Erfolg, der +Prozess lief weiter, und der Neustart setzte einen zweiten auf dieselbe `state.db`. + +Schweigen ist nur dann ein Todesnachweis, wenn es keinen anderen Zeugen gibt. Hält der +Manager ein Prozesshandle und sagt das „lebt noch", dann lebt der Prozess — er antwortet +bloß nicht mehr. Nur bei einer wiederaufgenommenen Instanz ohne Handle muss das Schweigen +reichen, weil mehr nicht zu haben ist. + +#### Und die Fristen greifen ineinander + +Die Instanz gibt sich zwei Minuten zum Auslaufen, der Manager wartet bis zu fünf +(`maxDrainWaitSeconds`), solange sie **meldet**, dass sie aufräumt. Wäre seine Frist +kürzer, schösse er mitten in das Aufräumen hinein, um das er gerade gebeten hat. Und +trotzdem endlich: Eine Instanz, die dauerhaft „ich räume noch auf" sagt, hängt genauso wie +eine, die schweigt. diff --git a/src/ClawdDotNet.App/AppHost.cs b/src/ClawdDotNet.App/AppHost.cs index 08e72ab..9169359 100644 --- a/src/ClawdDotNet.App/AppHost.cs +++ b/src/ClawdDotNet.App/AppHost.cs @@ -60,6 +60,22 @@ public sealed class AppHost : IAsyncDisposable public required ILoggerFactory LoggerFactory { get; init; } public required ToolRegistry Tools { get; init; } + /// + /// Das geordnete Ende dieser Instanz (#528). + /// + /// Wer die Instanz beenden will — der Instanzmanager über den Socket, ein + /// Mensch über das Fenster — ruft und + /// wartet, bevor er anstößt. Der Instanzmanager liest + /// unterdessen über den Puls und weiß + /// dadurch, dass hier aufgeräumt und nicht gehangen wird. + /// + /// Nicht required, sondern mit einem leeren Koordinator vorbelegt: Ein + /// Aufbau ohne angemeldete Arbeitsquellen hat nichts abzuwarten und endet sofort. So + /// gibt es diese Zusage immer, und niemand muss auf null prüfen, + /// bevor er eine Instanz geordnet beendet. + public ShutdownCoordinator Shutdown { get; init; } = + new(Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance); + /// Null, wenn kein OpenRouter-Schlüssel hinterlegt ist — dann laufen keine Agenten. public AgentEngine? Engine { get; private init; } @@ -177,8 +193,11 @@ public sealed class AppHost : IAsyncDisposable /// public required Func> SelectInstance { get; init; } - /// Wie der Lizenz-Torwächter mit dem Benutzer spricht. - public required ILicensePrompt License { get; init; } + /// Wie der Lizenz-Torwächter mit dem Benutzer spricht. Null im geführten Modus. + public ILicensePrompt? License { get; init; } + + /// Wahr, wenn die Instanz durch den Instanzmanager gestartet und geführt wird. + public bool IsManaged { get; init; } /// /// Telegram-Anmeldecode und 2FA-Passwort. Null lässt die MTProto-Anmeldung aus — @@ -270,17 +289,26 @@ public sealed class AppHost : IAsyncDisposable } // ─── 4. Lizenz ─── - var license = new LicenseGate( - new SettingsLicenseStore(settings), - loggerFactory.CreateLogger("ClawdDotNet.License"), - callbacks.License, - ReleaseInfo.Version); - - if (!await license.RunStartupCheckAsync(ct)) + LicenseGate? license = null; + if (!callbacks.IsManaged) { - logger.LogWarning("Start abgebrochen: keine gültige Lizenz."); - loggerFactory.Dispose(); - return new StartupResult(null, null); + var prompt = callbacks.License ?? new NonInteractiveLicensePrompt(Console.Error.WriteLine); + license = new LicenseGate( + new SettingsLicenseStore(settings), + loggerFactory.CreateLogger("ClawdDotNet.License"), + prompt, + ReleaseInfo.Version); + + if (!await license.RunStartupCheckAsync(ct)) + { + logger.LogWarning("Start abgebrochen: keine gültige Lizenz."); + loggerFactory.Dispose(); + return new StartupResult(null, null); + } + } + else + { + logger.LogInformation("Instanz wird vom Manager geführt (--managed): Lizenzprüfung erfolgt zentral im Manager."); } // ─── 5. Werkzeuge ─── @@ -307,7 +335,7 @@ public sealed class AppHost : IAsyncDisposable // Nichts freizugeben: Der Torwächter nutzt den gemeinsamen HttpClient des SDK. host.License = license; - if (license.IsEnforcementConfigured) + if (license is not null && license.IsEnforcementConfigured) { host.LicenseWatch = new LicenseWatch( license, loggerFactory.CreateLogger("ClawdDotNet.License")); @@ -381,7 +409,9 @@ public sealed class AppHost : IAsyncDisposable LogDirectory = logDirectory, LoggerFactory = loggerFactory, Tools = tools, - TelegramClient = telegram + TelegramClient = telegram, + Shutdown = new ShutdownCoordinator( + loggerFactory.CreateLogger("ClawdDotNet.Shutdown")) }; } @@ -445,9 +475,19 @@ public sealed class AppHost : IAsyncDisposable Board = board, Usage = usage, TelegramClient = telegram, - Status = new OpenRouterStatusService(instance.OpenRouterApiKey) + Status = new OpenRouterStatusService(instance.OpenRouterApiKey), + Shutdown = new ShutdownCoordinator( + loggerFactory.CreateLogger("ClawdDotNet.Shutdown")) }; + // Was beim Beenden auslaufen darf, bevor abgeschnitten wird (#528). Beide Quellen + // koennen nur zweierlei: die Tuer schliessen und sagen, wie viel noch laeuft. + host.Shutdown.Register(new WorkSource( + "Agentenläufe", () => engine?.OpenRunCount ?? 0, () => engine?.StopAccepting())); + + host.Shutdown.Register(new WorkSource( + "Aufgaben", () => scanner?.OpenCount ?? 0, () => scanner?.StopAccepting())); + host._shutdown.Add(() => { openRouter.Dispose(); return ValueTask.CompletedTask; }); logger.LogInformation("AgentEngine und Scanner erstellt, Chat-Verläufe geladen"); @@ -602,6 +642,14 @@ public sealed class AppHost : IAsyncDisposable if (_disposed) return; _disposed = true; + // Erst auslaufen lassen, dann abschneiden (#528). Laeuft das Auslaufen schon, + // wartet dieser Aufruf darauf statt es ein zweites Mal anzustossen - und wenn + // niemand darum gebeten hat, ist es hier in einem Wimpernschlag vorbei, weil + // dann nichts offen ist. Wer DisposeAsync ohne vorheriges BeginAsync ruft, + // bekommt so trotzdem das geordnete Ende. + try { await Shutdown.BeginAsync(); } + catch (Exception) { /* Beim Beenden zaehlt, dass alle Schritte drankommen */ } + foreach (var step in _shutdown) { try { await step(); } diff --git a/src/ClawdDotNet.Core/Config/InstanceConfig.cs b/src/ClawdDotNet.Core/Config/InstanceConfig.cs index a458a60..8760207 100644 --- a/src/ClawdDotNet.Core/Config/InstanceConfig.cs +++ b/src/ClawdDotNet.Core/Config/InstanceConfig.cs @@ -79,8 +79,14 @@ public sealed class InstanceConfig public int BackupKeepCount { get; set; } = 14; /// - /// Port der Weboberfläche. Je Instanz und nicht anwendungsweit: Zwei Instanzen auf - /// einer Maschine stritten sich sonst um einen Port. + /// Port der Weboberfläche. Entfällt mit dem Instanzmanager (E-M5): Instanzen hören + /// künftig ausschließlich auf ihrem Socket/Named Pipe; die Weboberfläche trägt der Manager. + /// + /// Noch ohne [Obsolete]. Das Attribut stand hier kurz und hat + /// sechs Warnungen erzeugt, ohne dass eine davon jemand hätte abstellen können — der + /// Port ist bis zum Abschluss von E-M5 der einzige Weg, auf dem eine eigenständige + /// Instanz ihre Oberfläche anbietet. Eine Warnung, die nur wegsehen lässt, ist + /// schlechter als keine; sie kommt zurück, wenn der Ersatz steht. /// [JsonPropertyName("webServerPort")] public int WebServerPort { get; set; } = 7001; diff --git a/src/ClawdDotNet.Core/Engine/AgentEngine.cs b/src/ClawdDotNet.Core/Engine/AgentEngine.cs index 72db757..4198804 100644 --- a/src/ClawdDotNet.Core/Engine/AgentEngine.cs +++ b/src/ClawdDotNet.Core/Engine/AgentEngine.cs @@ -145,10 +145,16 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut string? taskId = null, DelegationChain? delegation = null) { + // Vor allem anderen: Endet die Instanz gerade, faengt hier nichts Neues mehr an. + if (RefuseWhileShuttingDown(agentConfig) is { } zu) + return zu; + // Vor der ersten Anfrage prüfen — ein erschöpftes Budget soll gar nichts kosten. if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied) return denied; + using var lauf = TrackRun(); + var runId = Guid.NewGuid().ToString("N"); var chain = delegation ?? DelegationChain.Root(agentConfig.AgentId); var result = await RunCoreAsync(agentConfig, userMessage, instanceId, externalCt, runId, source, chain); @@ -340,9 +346,14 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut string? taskId = null, DelegationChain? delegation = null) { + if (RefuseWhileShuttingDown(agentConfig) is { } zu) + return zu; + if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied) return denied; + using var lauf = TrackRun(); + var runId = Guid.NewGuid().ToString("N"); var chain = delegation ?? DelegationChain.Root(agentConfig.AgentId); @@ -630,6 +641,63 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut get { lock (_lock) return _runningChats.Count; } } + // ─── Geordnetes Ende (#528) ─── + + private int _openRuns; + private int _accepting = 1; + + /// + /// Wie viele Agentenläufe gerade laufen — Chats und angestoßene Läufe. + /// + /// Nicht dasselbe wie : Der zählt Agenten + /// mit mindestens einem Chat, dieser zählt Läufe. Fürs Herunterfahren ist der + /// Lauf die Einheit — zwei Läufe desselben Agenten sind zwei Dinge, die zu Ende kommen + /// müssen. + /// + public int OpenRunCount => Volatile.Read(ref _openRuns); + + /// Nimmt die Engine noch neue Läufe an? + public bool IsAcceptingWork => Volatile.Read(ref _accepting) == 1; + + /// + /// Schließt die Tür: ab jetzt kein neuer Lauf mehr. + /// + /// Laufende werden nicht abgebrochen — das ist der ganze Punkt. Wer sie + /// abbrechen will, hat dafür AbortChat. + /// + public void StopAccepting() => Volatile.Write(ref _accepting, 0); + + private AgentRunResult? RefuseWhileShuttingDown(AgentConfig agentConfig) + => IsAcceptingWork + ? null + : new AgentRunResult( + agentConfig.AgentId, AgentRunStatus.ShuttingDown, + "[Die Instanz endet gerade — es werden keine neuen Läufe mehr angenommen]", + 0, 0, TimeSpan.Zero); + + /// + /// Zählt einen laufenden Lauf, solange sie lebt. + /// + /// Als using-Wert statt als try/finally von Hand, weil beide + /// Einstiege mehrere Rückgabewege haben und ein vergessener Weg den Zähler dauerhaft + /// verschöbe — eine Instanz, die dann nie mehr enden könnte, weil ein Lauf zu Buche + /// steht, den es nicht gibt. + /// + private RunScope TrackRun() => new(this); + + private readonly struct RunScope : IDisposable + { + private readonly AgentEngine _engine; + + public RunScope(AgentEngine engine) + { + _engine = engine; + Interlocked.Increment(ref engine._openRuns); + } + + public void Dispose() => Interlocked.Decrement(ref _engine._openRuns); + } + /// /// Momentaufnahme des Konversationskontexts eines Agenten — also der Nachrichten, /// die beim nächsten Schritt tatsächlich an das Modell gehen. diff --git a/src/ClawdDotNet.Core/Engine/AgentRunResult.cs b/src/ClawdDotNet.Core/Engine/AgentRunResult.cs index 4a536dc..4462e5a 100644 --- a/src/ClawdDotNet.Core/Engine/AgentRunResult.cs +++ b/src/ClawdDotNet.Core/Engine/AgentRunResult.cs @@ -38,5 +38,14 @@ public enum AgentRunStatus /// unbegrenzt warten darf (#461). Trifft nur delegierte Läufe — ein vom Menschen /// angestoßener Chat reiht sich weiterhin ein und wartet, so lange es dauert. /// - TargetBusy + TargetBusy, + + /// + /// Der Lauf fand nicht statt, weil die Instanz gerade geordnet endet (#528). + /// + /// Beim Herunterfahren wird zuerst die Tür geschlossen und dann gewartet. + /// Andersherum ginge die Zahl der offenen Läufe nie auf null, weil ständig neue + /// dazukämen — die Instanz käme nie zum Ende. + /// + ShuttingDown } diff --git a/src/ClawdDotNet.Core/Instances/InstanceEndpoint.cs b/src/ClawdDotNet.Core/Instances/InstanceEndpoint.cs new file mode 100644 index 0000000..2cf82c4 --- /dev/null +++ b/src/ClawdDotNet.Core/Instances/InstanceEndpoint.cs @@ -0,0 +1,207 @@ +using System.Net.Sockets; +using System.Security.Cryptography; +using System.Text; + +namespace ClawdDotNet.Core.Instances; + +/// +/// Der Weg, auf dem ein Instanzprozess von außen ansprechbar ist (#528, E-M1). +/// +/// Kein Port. Ports müssten vergeben, verwaltet und gegen Kollisionen +/// gesichert werden — genau das Problem, an dem die Vorbelegung 7001 scheitert, +/// sobald zwei Instanzen laufen. Ein Socket im Instanzverzeichnis braucht keine Vergabe: +/// Wo die Instanz liegt, liegt auch ihre Adresse. +/// +/// Die Zugriffsrechte stehen am Dateisystem, nicht in einem Token. Wer die +/// Socketdatei öffnen darf, darf mit der Instanz sprechen — und das darf nur, wer ohnehin +/// in ihr Verzeichnis sehen kann. Unter Linux setzt die Rechte auf +/// 0600, unter Windows übernimmt das die Named Pipe mit +/// CurrentUserOnly. +/// +/// Warum HTTP darüber. Der Manager leitet Anfragen weiter (E-M5). Bleibt das +/// Protokoll HTTP, ist Weiterleiten eine Weiterleitung und keine Übersetzung: Endpunkte, +/// Übertragungstypen und Ereignisstrom gelten unverändert weiter, es ändert sich nur die +/// Bindung. +/// +public static class InstanceEndpoint +{ + /// Der Name der Socketdatei im Instanzverzeichnis. + public const string SocketFileName = "manager.sock"; + + /// + /// Ob auf dieser Maschine eine Named Pipe statt eines Unix-Domain-Sockets benutzt + /// wird. + /// + /// Der Zielbetrieb ist Linux, entwickelt wird auf Windows — beide Wege müssen + /// tragen. Windows kann seit 10/1803 auch Unix-Domain-Sockets, aber nicht jede + /// Schicht darüber zieht mit; die Named Pipe ist dort der Weg, den das Betriebssystem + /// selbst vorsieht, samt eigener Rechteverwaltung. + /// + /// An Aufrufstellen, hinter denen etwas Plattformgebundenes steht, wird + /// trotzdem OperatingSystem.IsWindows() geschrieben: Die Plattformanalyse + /// erkennt nur den unmittelbaren Aufruf als Absicherung, nicht eine Eigenschaft, die + /// dasselbe sagt. + /// + public static bool UsesNamedPipe => OperatingSystem.IsWindows(); + + /// Die Socketdatei dieser Instanz. Auch unter Windows berechenbar — dort + /// bestimmt sie über nur den Namen, es entsteht keine Datei. + public static string SocketPath(string instanceDirectory) + => Path.Combine(Path.GetFullPath(instanceDirectory), SocketFileName); + + /// + /// Der Name der Named Pipe dieser Instanz. + /// + /// Pipenamen sind maschinenweit und kennen keine Verzeichnisse. Der Name muss + /// deshalb aus dem Instanzpfad entstehen, und zwar so, dass zwei Instanzen nie + /// denselben bekommen — sonst redete der Manager mit der falschen. Ein Fingerabdruck + /// des Pfades leistet das und trägt dabei nichts aus dem Pfad nach außen: Pipenamen + /// sind für jeden Prozess der Maschine sichtbar, ein Klartextpfad darin wäre ein + /// unnötiger Hinweis auf die Ablage. + /// + public static string PipeName(string instanceDirectory) + => "clawd-" + Fingerprint(instanceDirectory); + + /// Die Adresse, wie man sie einem Menschen ins Protokoll schreibt. + public static string Describe(string instanceDirectory) + => UsesNamedPipe + ? $@"\\.\pipe\{PipeName(instanceDirectory)}" + : SocketPath(instanceDirectory); + + /// + /// Räumt eine liegengebliebene Socketdatei weg. + /// + /// Ohne das startet die Instanz nach einem harten Ende nicht wieder. Ein + /// Unix-Domain-Socket ist eine Datei, und sie überlebt den Prozess, der sie angelegt + /// hat. Beim nächsten Binden kommt EADDRINUSE — von einem Prozess, den es + /// nicht mehr gibt. Genau der Fall aus #529: Windows hat die Anwendung erschlagen, + /// aufgeräumt hat niemand. + /// + /// Unter Windows ohne Wirkung: Eine Named Pipe verschwindet mit ihrem letzten + /// Halter. + /// + public static void ClearStale(string instanceDirectory) + { + if (OperatingSystem.IsWindows()) return; + + var path = SocketPath(instanceDirectory); + + try + { + if (File.Exists(path)) File.Delete(path); + } + catch (IOException) + { + // Kein Grund, den Start zu verhindern: Das Binden meldet gleich selbst, ob + // die Adresse frei ist, und diese Meldung ist die genauere. + } + catch (UnauthorizedAccessException) + { + } + } + + /// + /// Setzt die Rechte der Socketdatei auf 0600 — nur der eigene Benutzer. + /// + /// Erst nach dem Binden aufzurufen: Vorher gibt es die Datei nicht. Unter + /// Windows ohne Wirkung; dort trägt NamedPipeTransportOptions.CurrentUserOnly + /// dieselbe Zusage. + /// + public static void Restrict(string instanceDirectory) + { + if (OperatingSystem.IsWindows()) return; + + var path = SocketPath(instanceDirectory); + + try + { + if (File.Exists(path)) + File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException + or PlatformNotSupportedException) + { + // Der Aufrufer protokolliert. Ein Socket mit weiteren Rechten ist ein Mangel, + // aber keiner, der die Instanz am Laufen hindern sollte — im Verzeichnis + // daneben liegt ohnehin alles, was schützenswert ist, und dessen Rechte + // stehen bereits. + } + } + + /// + /// Ein , der über den Socket dieser Instanz spricht. + /// + /// Die Adresse in der Anfrage ist ein Platzhalter — http://instanz —, + /// weil HTTP einen Host verlangt und der Socket keinen hat. Verbunden wird über den + /// Rückruf, nicht über den Namen. + /// + public static HttpClient CreateClient(string instanceDirectory) + => new(CreateHandler(instanceDirectory)) { BaseAddress = new Uri("http://instanz") }; + + /// + public static HttpMessageHandler CreateHandler(string instanceDirectory) + { + if (OperatingSystem.IsWindows()) + { + var name = PipeName(instanceDirectory); + + return new SocketsHttpHandler + { + ConnectCallback = async (_, ct) => + { + var stream = new System.IO.Pipes.NamedPipeClientStream( + ".", name, + System.IO.Pipes.PipeDirection.InOut, + System.IO.Pipes.PipeOptions.Asynchronous + | System.IO.Pipes.PipeOptions.CurrentUserOnly); + + // 150 ms Frist: Ein lokaler Socket antwortet sofort (< 2 ms). + // Läuft die Instanz nicht, wartet Windows sonst bis zum Abbruch des Aufrufers. + await stream.ConnectAsync(150, ct); + return stream; + } + }; + } + + var endpoint = new UnixDomainSocketEndPoint(SocketPath(instanceDirectory)); + + return new SocketsHttpHandler + { + ConnectCallback = async (_, ct) => + { + var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified); + + try + { + await socket.ConnectAsync(endpoint, ct); + return new NetworkStream(socket, ownsSocket: true); + } + catch + { + socket.Dispose(); + throw; + } + } + }; + } + + /// + /// Fingerabdruck eines Instanzpfades: 16 Hexzeichen aus SHA-256. + /// + /// Unter Windows wird die Schreibweise vorher zusammengeführt — dort sind + /// C:\Instanzen\Test und c:\instanzen\test dasselbe Verzeichnis und + /// müssen denselben Pipenamen ergeben. Unter Linux sind es zwei Verzeichnisse und + /// dürfen es nicht. + /// + private static string Fingerprint(string instanceDirectory) + { + var full = Path.GetFullPath(instanceDirectory).TrimEnd( + Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); + + if (OperatingSystem.IsWindows() || OperatingSystem.IsMacOS()) + full = full.ToLowerInvariant(); + + var digest = SHA256.HashData(Encoding.UTF8.GetBytes(full)); + return Convert.ToHexStringLower(digest)[..16]; + } +} diff --git a/src/ClawdDotNet.Core/Instances/InstanceLayout.cs b/src/ClawdDotNet.Core/Instances/InstanceLayout.cs new file mode 100644 index 0000000..b8f187d --- /dev/null +++ b/src/ClawdDotNet.Core/Instances/InstanceLayout.cs @@ -0,0 +1,71 @@ +using ClawdDotNet.Core.Config; + +namespace ClawdDotNet.Core.Instances; + +/// +/// Wo die Verzeichnisse einer Instanz liegen. +/// +/// In Core, weil zwei Seiten es brauchen (#528): die Anwendung, die dorthin +/// schreibt, und der Instanzmanager, der beim Absturz einer Instanz den letzten Ausschnitt +/// ihres Protokolls in seine Meldung nimmt. Der Manager darf ClawdDotNet.App nicht +/// kennen — dort hängen sechzehn Werkzeugprojekte —, und dieselbe Rechnung an zwei Stellen +/// zu führen wäre die schlechtere Antwort darauf. +/// +public static class InstanceLayout +{ + /// + /// Wohin diese Instanz protokolliert. Zwei Regeln: + /// + /// Leer heißt <Instanzverzeichnis>/Logs — nicht mehr das + /// anwendungsweite Verzeichnis. Solange alle Instanzen in dieselben Dateien + /// schrieben, stand in Startup.log abwechselnd, was zwei Instanzen zu sagen + /// hatten, ohne Kennzeichnung, welche gerade spricht; im Mehrinstanzbetrieb war jede + /// Fehlersuche damit Ratearbeit (#528, Stufe 1). + /// + /// Ein relativer Wert zählt gegen das Instanzverzeichnis, nicht gegen + /// das Arbeitsverzeichnis des Prozesses. Sonst hängt der Ort davon ab, aus welchem + /// Verzeichnis jemand gestartet hat: Ein systemd-Dienst ohne WorkingDirectory= + /// startet in /, und "./Logs" zeigt dann auf /Logs — für ein + /// Dienstkonto nicht anlegbar. Beim Start aus dem Installationsverzeichnis schrieb + /// die Anwendung stattdessen in sich selbst, wo ein Update sie überschreibt. + /// + /// Die geladene Instanz — liefert Vorrang und Bezugspunkt. + /// Das Verzeichnis, aus dem die Instanz geladen wurde. + public static string ResolveLogDirectory(InstanceConfig instance, string instancePath) + => ResolveInstanceDirectory(instance.LogDirectory, "Logs", instance, instancePath); + + /// + /// Wohin die Sicherungen dieser Instanz gehen. Leer heißt + /// <Instanzverzeichnis>/Backups. + /// + /// Der gemeinsame Ordner war nicht nur unordentlich: Die Aufbewahrung räumt + /// dort nach dem Präfix backup_<Instanzname>_ auf, und bei zwei Namen, + /// die ineinander liegen (Test und Test_2), zählt die eine Instanz die + /// Archive der anderen mit (#528, Stufe 1). + /// + public static string ResolveBackupDirectory(InstanceConfig instance, string instancePath) + => ResolveInstanceDirectory(instance.BackupDirectory, "Backups", instance, instancePath); + + /// + /// Gemeinsame Auflösung: eingetragener Wert vor Vorgabe, relativ vor dem + /// Instanzverzeichnis. + /// + private static string ResolveInstanceDirectory( + string configured, string fallbackFolder, InstanceConfig instance, string instancePath) + { + // InstanceConfig.WorkingDirectory steht seit CreateInstance mit dem absoluten + // Instanzpfad in der Datei; instancePath ist derselbe Ort und trägt auch dann, + // wenn jemand das Feld von Hand geleert oder relativ gesetzt hat. + var instanceBase = Path.IsPathRooted(instance.WorkingDirectory) + ? instance.WorkingDirectory + : instancePath; + + if (string.IsNullOrWhiteSpace(configured)) + return Path.GetFullPath(Path.Combine(instanceBase, fallbackFolder)); + + return Path.GetFullPath( + Path.IsPathRooted(configured) + ? configured + : Path.Combine(instanceBase, configured)); + } +} diff --git a/src/ClawdDotNet.Core/Instances/ShutdownCoordinator.cs b/src/ClawdDotNet.Core/Instances/ShutdownCoordinator.cs new file mode 100644 index 0000000..5452391 --- /dev/null +++ b/src/ClawdDotNet.Core/Instances/ShutdownCoordinator.cs @@ -0,0 +1,276 @@ +using Microsoft.Extensions.Logging; + +namespace ClawdDotNet.Core.Instances; + +/// Wo eine Instanz beim Herunterfahren gerade steht. +public enum ShutdownPhase +{ + /// Niemand hat um ein Ende gebeten. Der Normalbetrieb. + Running, + + /// Die Tür ist zu, die offenen Arbeiten laufen aus. + Draining, + + /// Nichts mehr offen — oder die Frist ist abgelaufen. Der Wirt darf enden. + Done +} + +/// +/// Eine Stelle, an der Arbeit offen sein kann: Agentenläufe, Aufgaben, was noch kommt. +/// +/// Bewusst über Rückrufe und nicht als Schnittstelle an AgentEngine oder +/// TaskScanner: Die beiden sollen nicht wissen, dass es ein Herunterfahren gibt. +/// Sie können zwei Dinge — keine neue Arbeit mehr annehmen und sagen, wie viel noch +/// läuft. Was daraus folgt, entscheidet der Koordinator. +/// +/// Wie diese Quelle im Protokoll und in der Puls-Auskunft heißt. +/// Wie viele Arbeiten hier gerade noch laufen. +/// Schließt die Tür: ab jetzt keine neue Arbeit mehr. +public sealed record WorkSource( + string Name, + Func OpenCount, + Action StopAccepting); + +/// Was gerade offen ist, je Quelle. +public sealed record OpenWork(string Name, int Count); + +/// +/// Der Stand des Herunterfahrens, wie ihn der Instanzmanager über den Puls erfährt. +/// +/// Laufend, am Auslaufen, fertig. +/// Was noch offen ist, je Quelle. Leer heißt: nichts mehr. +/// Wie lange das Auslaufen schon dauert. +/// Wie viel von der Frist noch übrig ist. +public sealed record ShutdownSnapshot( + ShutdownPhase Phase, + IReadOnlyList Open, + TimeSpan Elapsed, + TimeSpan Remaining) +{ + /// Die Summe über alle Quellen. + public int TotalOpen => Open.Sum(o => o.Count); + + public static ShutdownSnapshot Idle { get; } = + new(ShutdownPhase.Running, [], TimeSpan.Zero, TimeSpan.Zero); +} + +/// +/// Das geordnete Ende einer Instanz: erst die Tür zu, dann auslaufen lassen, dann enden. +/// +/// Warum es das braucht. Bis hierher war jedes Beenden ein Abschneiden. +/// TaskScanner.DisposeAsync bricht den laufenden Takt über sein +/// CancellationToken ab — mitten in ProcessAsync, also nachdem eine +/// Aufgabe beansprucht wurde und bevor CompleteClaimAsync sie wieder +/// freigibt. Die Aufgabe steht danach auf running und bleibt dort, bis das Lease +/// abläuft. Ein Agentenlauf mitten im Werkzeugaufruf verliert seine Antwort ganz. +/// +/// Die Reihenfolge ist der ganze Trick. Erst wird die Tür geschlossen, dann +/// gewartet. Andersherum wartet man ewig: Der Scanner beansprucht im nächsten Takt die +/// nächste Aufgabe, und die Zahl der offenen Arbeiten geht nie auf null. +/// +/// Die Frist ist eine Zusage, keine Hoffnung. Nach +/// endet die Instanz, ob fertig oder nicht — sonst hinge sie an +/// einem Agentenlauf, der auf ein Modell wartet, das nicht antwortet. Was dann noch offen +/// war, steht im Protokoll; verschwiegen wird es nicht. +/// +/// Und der Manager sieht zu. geht über den +/// Puls-Endpunkt an den Instanzmanager. Solange hier Fortschritt gemeldet wird, wartet er +/// — er soll eine Instanz nicht abschießen, die gerade ordentlich aufräumt. +/// +public sealed class ShutdownCoordinator( + ILogger logger, + TimeSpan? budget = null, + TimeProvider? clock = null) +{ + private readonly TimeProvider _clock = clock ?? TimeProvider.System; + private readonly List _sources = []; + private readonly Lock _lock = new(); + private readonly TaskCompletionSource _finished = + new(TaskCreationOptions.RunContinuationsAsynchronously); + + private DateTimeOffset _startedAt; + private int _begun; + + /// + /// Wie lange das Auslaufen höchstens dauern darf. + /// + /// Zwei Minuten, weil ein Agentenlauf mit Werkzeugaufrufen selten kürzer ist und + /// selten länger dauert. Der Manager rechnet damit — seine eigene Frist muss größer + /// sein, sonst schießt er in das Aufräumen hinein. + /// + public TimeSpan Budget { get; } = budget ?? TimeSpan.FromMinutes(2); + + public ShutdownPhase Phase { get; private set; } = ShutdownPhase.Running; + + /// Ist erfüllt, sobald das Auslaufen vorbei ist — fertig oder abgelaufen. + public Task Finished => _finished.Task; + + /// + /// Meldet eine Stelle an, an der Arbeit offen sein kann. + /// + /// Vor aufzurufen. Wer sich später meldet, wird nicht + /// mehr abgewartet — und das ist richtig so: Was nach dem Schließen der Tür entsteht, + /// hätte gar nicht entstehen dürfen. + /// + public void Register(WorkSource source) + { + lock (_lock) _sources.Add(source); + } + + /// Der aktuelle Stand, für den Puls an den Manager. + public ShutdownSnapshot Snapshot() + { + lock (_lock) + { + if (Phase == ShutdownPhase.Running) + return ShutdownSnapshot.Idle; + + var elapsed = _clock.GetUtcNow() - _startedAt; + var remaining = Budget - elapsed; + + return new ShutdownSnapshot( + Phase, + Offen(), + elapsed, + remaining > TimeSpan.Zero ? remaining : TimeSpan.Zero); + } + } + + /// + /// Schließt die Tür und wartet, bis nichts mehr offen ist — höchstens + /// lang. + /// + /// Ein zweiter Aufruf wartet auf denselben Vorgang, statt einen neuen + /// anzustoßen. Beide Wege dorthin gibt es wirklich: Der Manager bittet über den + /// Socket, und gleichzeitig kann jemand am Fenster auf das Kreuz klicken. + /// + public async Task BeginAsync(CancellationToken ct = default) + { + if (Interlocked.Exchange(ref _begun, 1) != 0) + { + await _finished.Task.WaitAsync(ct).ConfigureAwait(false); + return; + } + + List quellen; + + lock (_lock) + { + _startedAt = _clock.GetUtcNow(); + Phase = ShutdownPhase.Draining; + quellen = [.. _sources]; + } + + // Erst die Tuer. Wer hier wartet, bevor er schliesst, wartet, bis der Strom + // ausfaellt. + foreach (var quelle in quellen) + { + try { quelle.StopAccepting(); } + catch (Exception ex) + { + logger.LogError(ex, + "{Quelle} liess sich nicht schliessen — es wird trotzdem gewartet.", + quelle.Name); + } + } + + var offenZuBeginn = Snapshot(); + + if (offenZuBeginn.TotalOpen == 0) + { + logger.LogInformation("Nichts mehr offen — die Instanz endet sofort."); + Vollenden(); + return; + } + + logger.LogInformation( + "Geordnetes Ende: {Anzahl} offene Arbeiten ({Aufschluesselung}). " + + "Es wird bis zu {Frist:0}s gewartet.", + offenZuBeginn.TotalOpen, Beschreiben(offenZuBeginn.Open), Budget.TotalSeconds); + + var deadline = _startedAt + Budget; + var zuletztGemeldet = offenZuBeginn.TotalOpen; + + while (_clock.GetUtcNow() < deadline) + { + var stand = Snapshot(); + + if (stand.TotalOpen == 0) + { + logger.LogInformation( + "Alle Arbeiten abgeschlossen nach {Dauer:0.0}s — die Instanz endet.", + stand.Elapsed.TotalSeconds); + + Vollenden(); + return; + } + + if (stand.TotalOpen != zuletztGemeldet) + { + // Fortschritt gehoert ins Protokoll. Nicht als Verzierung: Er ist der + // Unterschied zwischen "raeumt auf" und "haengt", und genau den muss + // hinterher jemand nachlesen koennen. + logger.LogInformation( + "Noch {Anzahl} offen ({Aufschluesselung}), {Rest:0}s Frist.", + stand.TotalOpen, Beschreiben(stand.Open), stand.Remaining.TotalSeconds); + + zuletztGemeldet = stand.TotalOpen; + } + + try + { + await Task.Delay(TimeSpan.FromMilliseconds(250), _clock, ct).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + // Abgebrochen heisst hier nicht "weitermachen", sondern "keine Zeit mehr". + // Der Wirt will enden; das Warten war der Dienst, nicht der Zweck. + break; + } + } + + var uebrig = Snapshot(); + + if (uebrig.TotalOpen > 0) + { + logger.LogWarning( + "Die Frist von {Frist:0}s ist abgelaufen, {Anzahl} Arbeiten waren noch offen " + + "({Aufschluesselung}). Sie werden abgebrochen.", + Budget.TotalSeconds, uebrig.TotalOpen, Beschreiben(uebrig.Open)); + } + + Vollenden(); + } + + private void Vollenden() + { + lock (_lock) Phase = ShutdownPhase.Done; + _finished.TrySetResult(); + } + + private List Offen() + { + var liste = new List(); + + foreach (var quelle in _sources) + { + int anzahl; + + try { anzahl = quelle.OpenCount(); } + catch (Exception ex) + { + // Eine Quelle, die beim Zaehlen stolpert, darf das Ende nicht aufhalten. + // Null ist hier die sichere Antwort: Sie verlaengert nichts. + logger.LogError(ex, "{Quelle} liess sich nicht zaehlen.", quelle.Name); + anzahl = 0; + } + + if (anzahl > 0) liste.Add(new OpenWork(quelle.Name, anzahl)); + } + + return liste; + } + + private static string Beschreiben(IReadOnlyList offen) + => offen.Count == 0 ? "nichts" : string.Join(", ", offen.Select(o => $"{o.Name}: {o.Count}")); +} diff --git a/src/ClawdDotNet.Core/Storage/SystemShell.cs b/src/ClawdDotNet.Core/Storage/SystemShell.cs index 9d04577..e03a5b9 100644 --- a/src/ClawdDotNet.Core/Storage/SystemShell.cs +++ b/src/ClawdDotNet.Core/Storage/SystemShell.cs @@ -79,6 +79,37 @@ public static class SystemShell } } + /// + /// Öffnet eine Internetadresse im Standard-Webbrowser des Systems. + /// + public static bool OpenUrl(string url) + { + if (string.IsNullOrWhiteSpace(url)) + return false; + + try + { + if (OperatingSystem.IsWindows()) + { + using var p = Process.Start(new ProcessStartInfo(url) { UseShellExecute = true }); + return p is not null; + } + if (OperatingSystem.IsLinux()) + { + return Start("xdg-open", [url]); + } + if (OperatingSystem.IsMacOS()) + { + return Start("open", [url]); + } + return false; + } + catch + { + return false; + } + } + /// /// Startet mit ArgumentList statt einer Argumentzeichenkette — so muss nichts /// maskiert werden, und ein Pfad mit Leerzeichen oder Anführungszeichen kann keinen diff --git a/src/ClawdDotNet.Core/Tasks/TaskScanner.cs b/src/ClawdDotNet.Core/Tasks/TaskScanner.cs index 5fe5ac7..367c735 100644 --- a/src/ClawdDotNet.Core/Tasks/TaskScanner.cs +++ b/src/ClawdDotNet.Core/Tasks/TaskScanner.cs @@ -89,12 +89,41 @@ public sealed class TaskScanner : IAsyncDisposable /// public bool HasStopped => _loop is { IsCompleted: true }; + // ─── Geordnetes Ende (#528) ─── + + private int _openRuns; + private int _accepting = 1; + + /// + /// Wie viele Aufgaben gerade tatsächlich laufen — also beansprucht und noch nicht + /// abgeschlossen. + /// + public int OpenCount => Volatile.Read(ref _openRuns); + + /// Beansprucht der Scanner noch neue Aufgaben? + public bool IsAcceptingWork => Volatile.Read(ref _accepting) == 1; + + /// + /// Schließt die Tür: kein neuer Takt, keine neue Beanspruchung. + /// + /// Warum das nicht dasselbe ist wie . Dispose + /// bricht den laufenden Takt über sein Token ab — mitten in ProcessAsync, also + /// nachdem eine Aufgabe beansprucht wurde und bevor CompleteClaimAsync sie + /// wieder freigibt. Sie steht danach auf running und bleibt dort bis zum + /// Ablauf des Lease. Wer geordnet enden will, schließt erst hier die Tür, wartet auf + /// gleich null und ruft Dispose erst dann. + /// + public void StopAccepting() => Volatile.Write(ref _accepting, 0); + private async Task RunLoopAsync(CancellationToken ct) { // PeriodicTimer über den TimeProvider — im Test steuerbar, im Betrieb driftfrei. using var timer = new PeriodicTimer(_tick, _clock); while (await timer.WaitForNextTickAsync(ct)) { + if (!IsAcceptingWork) + continue; // Die Tuer ist zu. Der Takt laeuft leer, bis Dispose ihn beendet. + try { await ScanOnceAsync(ct); @@ -113,6 +142,9 @@ public sealed class TaskScanner : IAsyncDisposable /// public async Task ScanOnceAsync(CancellationToken ct) { + if (!IsAcceptingWork) + return 0; + var now = _clock.GetUtcNow().UtcDateTime; var leaseCutoff = now - _lease; @@ -167,6 +199,9 @@ public sealed class TaskScanner : IAsyncDisposable /// public async Task RunTaskNowAsync(string taskId, CancellationToken ct) { + if (!IsAcceptingWork) + return false; + var task = await _repo.GetAsync(taskId, ct); if (task is null) return false; @@ -181,6 +216,23 @@ public sealed class TaskScanner : IAsyncDisposable } private async Task ProcessAsync(TaskItem task, string token, CancellationToken ct) + { + // Ab hier ist die Aufgabe beansprucht und steht auf `running`. Wer das + // Herunterfahren abwartet, wartet genau auf diesen Zaehler - denn erst + // CompleteClaimAsync weiter unten gibt sie wieder frei. + Interlocked.Increment(ref _openRuns); + + try + { + await ProcessCoreAsync(task, token, ct); + } + finally + { + Interlocked.Decrement(ref _openRuns); + } + } + + private async Task ProcessCoreAsync(TaskItem task, string token, CancellationToken ct) { bool ok; try diff --git a/src/ClawdDotNet.Desktop/App.axaml.cs b/src/ClawdDotNet.Desktop/App.axaml.cs index 3748d60..7436881 100644 --- a/src/ClawdDotNet.Desktop/App.axaml.cs +++ b/src/ClawdDotNet.Desktop/App.axaml.cs @@ -4,6 +4,8 @@ using Avalonia.Controls; using Avalonia.Controls.ApplicationLifetimes; using Avalonia.Markup.Xaml; using Avalonia.Threading; +using Avalonia.Layout; +using Avalonia.Media; using ClawdDotNet.App; using ClawdDotNet.App.Services; using ClawdDotNet.App.Settings; @@ -12,6 +14,8 @@ using ClawdDotNet.Desktop.ViewModels; using ClawdDotNet.Desktop.Views; using ClawdDotNet.Web; using ClawdDotNet.Core.Instances; +using ClawdDotNet.Core.Storage; +using Microsoft.Extensions.Logging; namespace ClawdDotNet.Desktop; @@ -106,6 +110,7 @@ public partial class App : Application { SelectInstance = SelectInstanceAsync, License = new AvaloniaLicensePrompt(), + IsManaged = _managed, TelegramLogin = prompt => AskAsync("Telegram Verifizierung", prompt), Telegram2FA = () => AskAsync("Telegram 2FA", "Bitte 2FA-Passwort eingeben:") }); @@ -152,10 +157,25 @@ public partial class App : Application // Der Manager bittet ueber den Socket, dieses Fenster nach vorn zu holen (E-M2). if (_web is not null) + { _web.Control.FocusRequested += () => BringToFront(desktop); + // Und er bittet, zu enden. Ohne diese Zeile lief die Bitte ins Leere: Der + // Endpunkt nahm sie an, antwortete mit 202 - und niemand hoerte zu. Der + // Manager wartete seine Frist ab und schoss den Prozess dann jedes Mal ab. + // Kopflos war das verdrahtet (HeadlessRun), mit Fenster nicht; und mit + // Fenster ist die Vorgabe (ManagerSettings.InstanceWindows). + _web.Control.ShutdownRequested += () => Dispatcher.UIThread.Post(() => + { + if (desktop.MainWindow is MainWindow fenster) + fenster.BeendenOhneRueckfrage(); + else + _ = BeendeGeordnetAsync(desktop, "Instanzmanager"); + }); + } + desktop.MainWindow.Show(); - desktop.MainWindow.Closed += (_, _) => desktop.Shutdown(); + desktop.MainWindow.Closed += (_, _) => _ = BeendeGeordnetAsync(desktop, "Fenster"); await OfferUpdateAsync(_host, desktop); } @@ -373,14 +393,29 @@ public partial class App : Application /// Reihenfolge wie dort: erst geordnet herunterfahren, dann den neuen Prozess /// starten. Andersherum liefen kurz zwei Prozesse auf derselben Datenbank. /// + private enum StartModeChoice + { + LaunchManager, + Standalone, + Cancel + } + + private enum StandaloneSwitchChoice + { + LaunchManager, + SwitchStandalone, + Cancel + } + + /// + /// Instanzwechsel aus der laufenden Anwendung. + /// private async Task SwitchInstanceAsync(IClassicDesktopStyleApplicationLifetime desktop) { if (_host is null) return; if (_managed) { - // Sollte gar nicht erst aufrufbar sein (CanSwitchInstance), aber ein zweites - // Schloss an der Tuer, hinter der ein Selbst-Neustart wartet, ist billig. await new AvaloniaLicensePrompt().ShowInfoAsync( "ClawdDotNet – Instanzwechsel", "Diese Instanz wird vom Instanzmanager geführt. Gewechselt wird dort — " @@ -390,6 +425,18 @@ public partial class App : Application return; } + // Im Standalone-Modus den Benutzer fragen: + var switchChoice = await AskStandaloneSwitchModeAsync(desktop.MainWindow); + if (switchChoice == StandaloneSwitchChoice.LaunchManager) + { + LaunchInstanceManagerAndOpenBrowser(); + return; + } + if (switchChoice == StandaloneSwitchChoice.Cancel) + { + return; + } + var viewModel = new InstancePickerViewModel(_host.Directories, _host.InstancePath); var window = new InstancePickerWindow { DataContext = viewModel }; @@ -408,8 +455,6 @@ public partial class App : Application if (path is null) return; if (string.Equals(path, _host.InstancePath, StringComparison.OrdinalIgnoreCase)) return; - await ShutdownWebAsync(); - var executable = Environment.ProcessPath; if (executable is null) @@ -421,14 +466,13 @@ public partial class App : Application return; } - await _host.DisposeAsync(); - + // Neue Instanz mit UseShellExecute = true starten (keine geerbten Datei- oder Socket-Handles) try { Process.Start(new ProcessStartInfo(executable) { ArgumentList = { InstanceArgument, path }, - UseShellExecute = false + UseShellExecute = true }); } catch (Exception ex) @@ -436,8 +480,340 @@ public partial class App : Application await new AvaloniaLicensePrompt().ShowErrorAsync( "ClawdDotNet – Instanzwechsel", $"Neustart fehlgeschlagen: {ex.Message}"); + return; } + // Hauptfenster sofort verbergen, damit es nicht eingefroren sichtbar bleibt + if (desktop.MainWindow is { } mainWin) + { + mainWin.Hide(); + } + + await ShutdownWebAsync(); + + var hostToDispose = _host; + _host = null; + if (hostToDispose is not null) + { + await hostToDispose.DisposeAsync(); + } + + // Sauber beenden + await Dispatcher.UIThread.InvokeAsync(() => + { + desktop.Shutdown(0); + Environment.Exit(0); + }); + } + + private static void LaunchInstanceManagerAndOpenBrowser() + { + var exePath = FindInstanceManagerExecutable(); + if (exePath is null) + { + _ = new AvaloniaLicensePrompt().ShowErrorAsync( + "ClawdDotNet – Instanzmanager", + "Die Programmdatei des Instanzmanagers (ClawdDotNet.Instanzmanager.exe) wurde nicht gefunden."); + return; + } + + try + { + Process.Start(new ProcessStartInfo(exePath) + { + UseShellExecute = true + }); + + SystemShell.OpenUrl($"http://localhost:{ManagerPort()}/#/instanzen"); + } + catch (Exception ex) + { + _ = new AvaloniaLicensePrompt().ShowErrorAsync( + "ClawdDotNet – Instanzmanager", + $"Konnte Instanzmanager nicht starten: {ex.Message}"); + } + } + + /// + /// Sucht die Programmdatei des Instanzmanagers. + /// + /// Die Pfade werden aus Segmenten gebaut, nicht als Zeichenkette. Hier + /// stand @"..\..\..\..\ClawdDotNet.ManagerApp\bin\Debug\net10.0" — unter Linux, + /// dem einzigen Zielbetrieb, ist das kein Pfad, sondern ein einziger Dateiname mit + /// Rückstrichen darin, und die Suche ging dort nie auf. + /// + /// Die Entwicklungspfade bleiben, weil im Betrieb beide Programme + /// nebeneinanderliegen und der erste Versuch trifft; sie kosten dort nur zwei + /// vergebliche File.Exists. + /// + private static string? FindInstanceManagerExecutable() + { + var exeName = OperatingSystem.IsWindows() + ? "ClawdDotNet.Instanzmanager.exe" + : "ClawdDotNet.Instanzmanager"; + + var nebenan = Path.Combine(AppContext.BaseDirectory, exeName); + if (File.Exists(nebenan)) return nebenan; + + string[][] entwicklungspfade = + [ + ["..", "..", "..", "..", "ClawdDotNet.ManagerApp", "bin", "Debug", "net10.0"], + ["..", "..", "..", "..", "..", "src", "ClawdDotNet.ManagerApp", "bin", "Debug", "net10.0"] + ]; + + foreach (var segmente in entwicklungspfade) + { + var pfad = Path.GetFullPath(Path.Combine( + [AppContext.BaseDirectory, .. segmente, exeName])); + + if (File.Exists(pfad)) return pfad; + } + + return null; + } + + /// + /// Der Port, auf dem der Instanzmanager seine Oberfläche anbietet. + /// + /// Aus manager.json gelesen und nicht fest eingetragen: Wer den Port + /// dort ändert, bekäme sonst einen Browser auf eine Adresse, an der nichts + /// antwortet. Diese Anwendung kennt den Typ hinter der Datei nicht — sie liest das + /// eine Feld, das sie braucht, und nimmt bei jedem Zweifel die Vorgabe. + /// + private static int ManagerPort() + { + const int vorgabe = 7000; + + try + { + var datei = Path.Combine(AppPaths.ConfigDirectory, "manager.json"); + if (!File.Exists(datei)) return vorgabe; + + using var doc = System.Text.Json.JsonDocument.Parse(File.ReadAllText(datei)); + + return doc.RootElement.TryGetProperty("webUiPort", out var port) + && port.ValueKind == System.Text.Json.JsonValueKind.Number + && port.TryGetInt32(out var wert) + && wert is > 0 and < 65536 + ? wert + : vorgabe; + } + catch (Exception) + { + // Eine unlesbare Managerdatei ist kein Grund, den Browser gar nicht zu oeffnen. + return vorgabe; + } + } + + private static async Task AskStandaloneSwitchModeAsync(Window? owner) + => await Dispatcher.UIThread.InvokeAsync(async () => + { + var completion = new TaskCompletionSource(); + + var managerBtn = new Button + { + Content = "Instanzmanager starten (Empfohlen)", + Classes = { "primary" } + }; + + var switchBtn = new Button + { + Content = "Instanz trotzdem wechseln" + }; + + var cancelBtn = new Button + { + Content = "Abbrechen", + IsCancel = true + }; + + var window = new Window + { + Title = "ClawdDotNet – Instanzwechsel (Standalone)", + Width = 540, + SizeToContent = SizeToContent.Height, + CanResize = false, + WindowStartupLocation = WindowStartupLocation.CenterScreen, + Icon = owner?.Icon, + Content = new StackPanel + { + Margin = new Thickness(20), + Spacing = 16, + Children = + { + new TextBlock + { + Text = "Achtung: Standalone-Modus", + Classes = { "h1" } + }, + new TextBlock + { + Text = "Diese Instanz läuft eigenständig ohne Instanzmanager.\n\n" + + "Wenn du die Instanz hier wechselst, wird diese Instanz vollständig beendet " + + "und alle laufenden Agenten und Hintergrunddienste werden gestoppt.\n\n" + + "Empfehlung: Starte stattdessen den Instanzmanager, um mehrere Instanzen gleichzeitig und unabhängig voneinander zu betreiben.", + TextWrapping = TextWrapping.Wrap + }, + new StackPanel + { + Orientation = Orientation.Horizontal, + Spacing = 10, + HorizontalAlignment = HorizontalAlignment.Right, + Children = { cancelBtn, switchBtn, managerBtn } + } + } + } + }; + + managerBtn.Click += (_, _) => + { + completion.TrySetResult(StandaloneSwitchChoice.LaunchManager); + window.Close(); + }; + + switchBtn.Click += (_, _) => + { + completion.TrySetResult(StandaloneSwitchChoice.SwitchStandalone); + window.Close(); + }; + + cancelBtn.Click += (_, _) => + { + completion.TrySetResult(StandaloneSwitchChoice.Cancel); + window.Close(); + }; + + window.Closed += (_, _) => completion.TrySetResult(StandaloneSwitchChoice.Cancel); + + if (owner is not null) + await window.ShowDialog(owner); + else + window.Show(); + + return await completion.Task; + }); + + private static async Task AskStartModeAsync() + => await Dispatcher.UIThread.InvokeAsync(async () => + { + var completion = new TaskCompletionSource(); + + var managerBtn = new Button + { + Content = "Instanzmanager starten (Empfohlen)", + Classes = { "primary" } + }; + + var standaloneBtn = new Button + { + Content = "Als Standalone-Instanz starten" + }; + + var cancelBtn = new Button + { + Content = "Abbrechen", + IsCancel = true + }; + + var window = new Window + { + Title = "ClawdDotNet – Startmodus wählen", + Width = 540, + SizeToContent = SizeToContent.Height, + CanResize = false, + WindowStartupLocation = WindowStartupLocation.CenterScreen, + Content = new StackPanel + { + Margin = new Thickness(22), + Spacing = 16, + Children = + { + new TextBlock + { + Text = "Wie möchtest du ClawdDotNet starten?", + Classes = { "h1" } + }, + new TextBlock + { + Text = "• Instanzmanager (Empfohlen):\n" + + " Startet den zentralen Hintergrund-Manager und öffnet die Verwaltung im Browser. " + + "Ermöglicht den stabilen Dauerbetrieb mehrerer Instanzen parallel ohne Absturzrisiko.\n\n" + + "• Standalone-Modus:\n" + + " Startet genau eine Instanz direkt als einzelnes Desktop-Fenster.", + TextWrapping = TextWrapping.Wrap + }, + new StackPanel + { + Orientation = Orientation.Horizontal, + Spacing = 10, + HorizontalAlignment = HorizontalAlignment.Right, + Children = { cancelBtn, standaloneBtn, managerBtn } + } + } + } + }; + + managerBtn.Click += (_, _) => + { + completion.TrySetResult(StartModeChoice.LaunchManager); + window.Close(); + }; + + standaloneBtn.Click += (_, _) => + { + completion.TrySetResult(StartModeChoice.Standalone); + window.Close(); + }; + + cancelBtn.Click += (_, _) => + { + completion.TrySetResult(StartModeChoice.Cancel); + window.Close(); + }; + + window.Closed += (_, _) => completion.TrySetResult(StartModeChoice.Cancel); + + window.Show(); + return await completion.Task; + }); + + private int _beendetSich; + + /// + /// Das geordnete Ende dieser Instanz — der eine Weg, egal wer darum gebeten hat. + /// + /// Erst auslaufen lassen, dann abschneiden. Laufende Agenten und + /// beanspruchte Aufgaben bekommen ihre Frist + /// (), bevor Weboberfläche und Aufbau fallen. Ohne + /// das endete eine Aufgabe mitten in ProcessAsync und bliebe bis zum Ablauf + /// ihres Lease auf running stehen. + /// + /// Und nicht im Rückruf von desktop.ShutdownRequested. Avalonia + /// wartet dort nicht auf async-Behandlungen; was länger dauert als ein + /// Wimpernschlag, läuft gegen einen Prozess, der schon weg ist. Deshalb erst + /// aufräumen und dann Shutdown rufen — der Rückruf dort bleibt als + /// zweites Schloss stehen und tut dank der Sperren beim zweiten Mal nichts. + /// + private async Task BeendeGeordnetAsync( + IClassicDesktopStyleApplicationLifetime desktop, string grund) + { + if (Interlocked.Exchange(ref _beendetSich, 1) != 0) return; + + var host = _host; + + if (host is not null) + { + host.LoggerFactory.CreateLogger("ClawdDotNet.Shutdown") + .LogInformation("Beendigung angefordert ({Grund}).", grund); + + try { await host.Shutdown.BeginAsync(); } + catch (Exception) { /* Beim Beenden zaehlt, dass alle Schritte drankommen */ } + } + + await ShutdownWebAsync(); + + if (host is not null) await host.DisposeAsync(); + await Dispatcher.UIThread.InvokeAsync(() => desktop.Shutdown()); } @@ -458,12 +834,6 @@ public partial class App : Application /// /// Instanzauswahl beim Start. - /// - /// Kam die Anwendung mit --instance hoch, wird nicht gefragt: Dann hat - /// der Benutzer die Instanz im vorigen Prozess bereits gewaehlt, und ein zweiter - /// Dialog waere nur die Frage nach der schon gegebenen Antwort. Der Wert wird einmal - /// verbraucht — bleibt der Pfad ungueltig, erscheint doch der Dialog, statt dass der - /// Start wortlos scheitert. /// private async Task SelectInstanceAsync(InstanceDirectoryManager directories) { @@ -473,6 +843,20 @@ public partial class App : Application if (preselected is not null && Directory.Exists(preselected)) return preselected; + if (!_managed) + { + var choice = await AskStartModeAsync(); + if (choice == StartModeChoice.LaunchManager) + { + LaunchInstanceManagerAndOpenBrowser(); + return null; + } + if (choice == StartModeChoice.Cancel) + { + return null; + } + } + return await ShowInstancePickerAsync(directories); } diff --git a/src/ClawdDotNet.Desktop/HeadlessRun.cs b/src/ClawdDotNet.Desktop/HeadlessRun.cs index c4f5ae1..281974d 100644 --- a/src/ClawdDotNet.Desktop/HeadlessRun.cs +++ b/src/ClawdDotNet.Desktop/HeadlessRun.cs @@ -54,10 +54,10 @@ internal static class HeadlessRun { SelectInstance = _ => Task.FromResult(instancePath), - // Fragt nicht, sondern meldet, was zu tun ist. Mit E-M3 wandert die - // Lizenzpruefung ohnehin in den Instanzmanager; bis dahin ist das hier der - // ehrliche Weg: Ein Schluessel wird vorab hinterlegt, nicht erfragt. - License = new NonInteractiveLicensePrompt(Console.Error.WriteLine) + // Fragt nicht, sondern meldet, was zu tun ist. Im geführten Modus (E-M3) + // entfällt die lokale Prüfung; der Manager prüft zentral. + License = new NonInteractiveLicensePrompt(Console.Error.WriteLine), + IsManaged = CommandLine.IsManaged(args) }); if (host is null) diff --git a/src/ClawdDotNet.Desktop/Views/MainWindow.axaml.cs b/src/ClawdDotNet.Desktop/Views/MainWindow.axaml.cs index 968bdc7..a1c654c 100644 --- a/src/ClawdDotNet.Desktop/Views/MainWindow.axaml.cs +++ b/src/ClawdDotNet.Desktop/Views/MainWindow.axaml.cs @@ -1,13 +1,48 @@ +using Avalonia; using Avalonia.Controls; +using Avalonia.Threading; using ClawdDotNet.Desktop.ViewModels; namespace ClawdDotNet.Desktop.Views; public partial class MainWindow : Window { + private bool _confirmedClose; + public MainWindow() { InitializeComponent(); + Closing += OnClosing; + } + + /// + /// Schließt ohne Rückfrage — für eine Beendigung, die nicht von diesem Fenster ausgeht. + /// + /// Warum das nötig ist. Der Bestätigungsdialog schützt vor dem + /// versehentlichen Klick eines Menschen. Bittet dagegen der Instanzmanager über den + /// Socket, steht niemand davor: Der Dialog bliebe offen, die zehn Sekunden liefen ab, + /// und niemand klickte. Der Manager wartete seine Frist ab und schösse den Prozess + /// dann ab — der Dialog, der ein hartes Ende verhindern soll, hätte es garantiert. + /// + public void BeendenOhneRueckfrage() + { + _confirmedClose = true; + Close(); + } + + private async void OnClosing(object? sender, WindowClosingEventArgs e) + { + if (_confirmedClose) return; + + // Schließen zunächst abbrechen, um Bestätigungsdialog anzuzeigen + e.Cancel = true; + + var confirmed = await ShowExitConfirmationAsync(this); + if (confirmed) + { + _confirmedClose = true; + Close(); + } } protected override void OnDataContextChanged(EventArgs e) @@ -21,4 +56,113 @@ public partial class MainWindow : Window if (DataContext is MainWindowViewModel vm) vm.RequestExit += Close; } + + internal static async Task ShowExitConfirmationAsync(Window? owner) + { + var completion = new TaskCompletionSource(); + var remainingSeconds = 10; + + var cancelBtn = new Button + { + Content = "Abbrechen (Instanz läuft weiter)", + IsCancel = true + }; + + var exitBtn = new Button + { + Content = $"Instanz beenden ({remainingSeconds}s)", + IsEnabled = false + }; + exitBtn.Classes.Add("danger"); + + var countdownText = new TextBlock + { + Text = $"Bestätigung gesperrt: Noch {remainingSeconds} Sekunden…", + Classes = { "caption" } + }; + + var timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(1) }; + timer.Tick += (_, _) => + { + remainingSeconds--; + if (remainingSeconds > 0) + { + countdownText.Text = $"Bestätigung gesperrt: Noch {remainingSeconds} Sekunden…"; + exitBtn.Content = $"Instanz beenden ({remainingSeconds}s)"; + } + else + { + timer.Stop(); + exitBtn.IsEnabled = true; + exitBtn.Content = "Instanz jetzt endgültig beenden"; + countdownText.Text = "Sperre aufgehoben — Bestätigung jetzt möglich."; + } + }; + + var window = new Window + { + Title = "ClawdDotNet – Instanz beenden", + Width = 500, + SizeToContent = SizeToContent.Height, + CanResize = false, + WindowStartupLocation = WindowStartupLocation.CenterScreen, + Icon = owner?.Icon, + Content = new StackPanel + { + Margin = new Thickness(20), + Spacing = 16, + Children = + { + new TextBlock + { + Text = "Achtung: Produktivinstanz beenden", + Classes = { "h1" } + }, + new TextBlock + { + Text = "ClawdDotNet-Instanzen sind auf dauerhaften Dauerbetrieb ausgelegt. " + + "Das Beenden stoppt alle aktiven Agenten, Automationen, Web-Zugriffe und Hintergrundaufgaben dieser Instanz geordnet.", + TextWrapping = Avalonia.Media.TextWrapping.Wrap + }, + countdownText, + new StackPanel + { + Orientation = Avalonia.Layout.Orientation.Horizontal, + Spacing = 10, + HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Right, + Children = { cancelBtn, exitBtn } + } + } + } + }; + + cancelBtn.Click += (_, _) => + { + timer.Stop(); + completion.TrySetResult(false); + window.Close(); + }; + + exitBtn.Click += (_, _) => + { + timer.Stop(); + completion.TrySetResult(true); + window.Close(); + }; + + window.Closed += (_, _) => + { + timer.Stop(); + completion.TrySetResult(false); + }; + + timer.Start(); + + if (owner is not null) + await window.ShowDialog(owner); + else + window.Show(); + + return await completion.Task; + } } diff --git a/src/ClawdDotNet.Manager.Web/Endpoints.cs b/src/ClawdDotNet.Manager.Web/Endpoints.cs index 3f226c1..371435d 100644 --- a/src/ClawdDotNet.Manager.Web/Endpoints.cs +++ b/src/ClawdDotNet.Manager.Web/Endpoints.cs @@ -1,3 +1,8 @@ +using System.IO; +using System.Text.Json; +using ClawdDotNet.Core.Backup; +using ClawdDotNet.Core.Config; +using ClawdDotNet.Core.Instances; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Routing; @@ -21,6 +26,32 @@ public sealed record NewInstanceDto(string Name); /// Antwort auf etwas, das gelingen oder scheitern kann. public sealed record OutcomeDto(bool Ok, string Meldung); +/// Eine gefundene Sicherungsdatei einer Instanz. +public sealed record BackupItemDto( + string FileName, + long SizeBytes, + DateTime CreatedAt, + string InstanceName, + string Secrets, + int SecretCount, + int FileCount); + +/// Übersicht aller Sicherungen einer Instanz mit Verzeichnisangabe. +public sealed record BackupListDto( + string Directory, + IReadOnlyList Backups); + +/// Parameter zum Anlegen einer neuen Sicherung. +public sealed record CreateBackupRequestDto( + string? Secrets, + string? Passphrase, + bool IncludeLogs, + bool IncludeChatHistory); + +/// Parameter zur Wiederherstellung einer Sicherung. +public sealed record RestoreBackupRequestDto( + string? Passphrase); + /// /// Die HTTP-Fläche des Managers. /// @@ -125,6 +156,190 @@ internal static class ManagerEndpoints $"Instanz '{instanz.Name}' hört nicht und ist von hier aus nicht zu beenden."), statusCode: StatusCodes.Status409Conflict); }); + + // ─── Datensicherung & Wiederherstellung (#530, Stufe 6) ─── + + verwaltung.MapGet("/instanzen/{id}/backups", async ( + string id, InstanceRegistry registry, ILoggerFactory protokoll, + CancellationToken ct) => + { + if (Find(registry, id) is not { } instanz) + return Results.NotFound(new OutcomeDto(false, $"Es gibt keine Instanz '{id}'.")); + + var backupDir = GetBackupDirectory(instanz, Log(protokoll)); + if (!Directory.Exists(backupDir)) + return Results.Ok(new BackupListDto(backupDir, [])); + + var service = new BackupService(); + var list = new List(); + + var files = new DirectoryInfo(backupDir) + .GetFiles("*.zip") + .OrderByDescending(f => f.LastWriteTimeUtc); + + foreach (var f in files) + { + ct.ThrowIfCancellationRequested(); + try + { + var manifest = await service.InspectAsync(f.FullName, ct); + list.Add(new BackupItemDto( + f.Name, + f.Length, + manifest.CreatedAt != default ? manifest.CreatedAt : f.CreationTimeUtc, + manifest.InstanceName, + manifest.Secrets, + manifest.SecretCount, + manifest.Files.Count)); + } + catch + { + list.Add(new BackupItemDto( + f.Name, + f.Length, + f.CreationTimeUtc, + instanz.Name, + "Unbekannt", + 0, + 0)); + } + } + + return Results.Ok(new BackupListDto(backupDir, list)); + }); + + verwaltung.MapPost("/instanzen/{id}/backups", async ( + string id, CreateBackupRequestDto? req, InstanceRegistry registry, + ILoggerFactory protokoll, CancellationToken ct) => + { + if (Find(registry, id) is not { } instanz) + return Results.NotFound(new OutcomeDto(false, $"Es gibt keine Instanz '{id}'.")); + + var backupDir = GetBackupDirectory(instanz, Log(protokoll)); + Directory.CreateDirectory(backupDir); + + var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss"); + var safeName = string.Join("_", instanz.Name.Split(Path.GetInvalidFileNameChars())); + var zipName = $"backup_{safeName}_{timestamp}.zip"; + var zipPath = Path.Combine(backupDir, zipName); + + var secretMode = string.Equals(req?.Secrets, "Passphrase", StringComparison.OrdinalIgnoreCase) + ? SecretMode.Passphrase + : SecretMode.Exclude; + + if (secretMode == SecretMode.Passphrase && string.IsNullOrWhiteSpace(req?.Passphrase)) + return Results.BadRequest(new OutcomeDto(false, "Für den Schutz der Zugangsdaten wird eine Passphrase benötigt.")); + + var options = new BackupOptions + { + Secrets = secretMode, + Passphrase = req?.Passphrase, + IncludeLogs = req?.IncludeLogs ?? false, + IncludeChatHistory = req?.IncludeChatHistory ?? true + }; + + try + { + var service = new BackupService(); + var result = await service.CreateAsync(instanz.Directory, zipPath, options, ct); + return Results.Ok(new OutcomeDto(true, $"Sicherung '{zipName}' erfolgreich erstellt ({result.SizeBytes / 1024} KB).")); + } + catch (Exception ex) + { + return Results.BadRequest(new OutcomeDto(false, $"Sicherung fehlgeschlagen: {ex.Message}")); + } + }); + + verwaltung.MapPost("/instanzen/{id}/backups/{filename}/restore", async ( + string id, string filename, RestoreBackupRequestDto? req, ManagerCore manager, + InstanceRegistry registry, ILoggerFactory protokoll) => + { + if (Find(registry, id) is not { } instanz) + return Results.NotFound(new OutcomeDto(false, $"Es gibt keine Instanz '{id}'.")); + + if (filename.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || Path.GetFileName(filename) != filename) + return Results.BadRequest(new OutcomeDto(false, "Ungültiger Dateiname.")); + + var backupDir = GetBackupDirectory(instanz, Log(protokoll)); + var zipPath = Path.Combine(backupDir, filename); + + if (!File.Exists(zipPath)) + return Results.NotFound(new OutcomeDto(false, $"Sicherungsdatei '{filename}' wurde nicht gefunden.")); + + // Ausdruecklich ohne das Token der Anfrage: Wer mitten im Zurueckspielen den + // Browser schliesst, hinterliesse sonst ein halb ueberschriebenes + // Instanzverzeichnis - und das wuerde anschliessend auch noch gestartet. Was + // hier beginnt, wird zu Ende gebracht. + var ct = CancellationToken.None; + + var wasRunning = instanz.Condition is InstanceCondition.Running or InstanceCondition.Silent; + if (wasRunning) + { + var stopped = await manager.StopInstanceAsync(instanz.Directory, ct); + if (!stopped) + { + return Results.Json( + new OutcomeDto(false, $"Instanz '{instanz.Name}' konnte vor der Wiederherstellung nicht angehalten werden."), + statusCode: StatusCodes.Status409Conflict); + } + } + + try + { + var service = new BackupService(); + var restoreResult = await service.RestoreAsync( + zipPath, + instanz.Directory, + new RestoreOptions + { + Passphrase = req?.Passphrase, + Overwrite = true + }, + ct); + + if (wasRunning) + { + await manager.StartInstanceAsync(instanz.Directory, ct); + } + + return Results.Ok(new OutcomeDto(true, $"Sicherung '{filename}' erfolgreich wiederhergestellt ({restoreResult.Written.Count} Dateien geschrieben).")); + } + catch (Exception ex) + { + if (wasRunning) + { + try { await manager.StartInstanceAsync(instanz.Directory, ct); } catch { } + } + + return Results.BadRequest(new OutcomeDto(false, $"Wiederherstellung fehlgeschlagen: {ex.Message}")); + } + }); + + verwaltung.MapDelete("/instanzen/{id}/backups/{filename}", ( + string id, string filename, InstanceRegistry registry, ILoggerFactory protokoll) => + { + if (Find(registry, id) is not { } instanz) + return Results.NotFound(new OutcomeDto(false, $"Es gibt keine Instanz '{id}'.")); + + if (filename.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || Path.GetFileName(filename) != filename) + return Results.BadRequest(new OutcomeDto(false, "Ungültiger Dateiname.")); + + var backupDir = GetBackupDirectory(instanz, Log(protokoll)); + var zipPath = Path.Combine(backupDir, filename); + + if (!File.Exists(zipPath)) + return Results.NotFound(new OutcomeDto(false, $"Sicherungsdatei '{filename}' nicht gefunden.")); + + try + { + File.Delete(zipPath); + return Results.Ok(new OutcomeDto(true, $"Sicherungsdatei '{filename}' gelöscht.")); + } + catch (Exception ex) + { + return Results.BadRequest(new OutcomeDto(false, $"Konnte nicht gelöscht werden: {ex.Message}")); + } + }); } // ─── Der Ereignisstrom ─── @@ -174,7 +389,44 @@ internal static class ManagerEndpoints InstanceRouting.IdOf(instanz), instanz.Name, instanz.Condition.ToString(), instanz.ProcessId, instanz.AutostartByManager); + private static ILogger Log(ILoggerFactory factory) + => factory.CreateLogger("ClawdDotNet.Manager.Web"); + private static ManagedInstance? Find(InstanceRegistry registry, string id) => registry.Instances.FirstOrDefault( i => string.Equals(InstanceRouting.IdOf(i), id, StringComparison.OrdinalIgnoreCase)); + + /// + /// Wo die Sicherungen dieser Instanz liegen. + /// + /// Eine unlesbare Instanzdatei wird gemeldet, nicht verschluckt. Sonst + /// landeten die Sicherungen wortlos im Standardverzeichnis statt im eingestellten — + /// und niemand sähe, warum die alten verschwunden sind. Genau diese Bauart hat + /// manager.json schon einmal eine halbe Stunde Fehlersuche gekostet. + /// + private static string GetBackupDirectory(ManagedInstance instanz, ILogger? logger = null) + { + InstanceConfig? config = null; + var settingsFile = Path.Combine(instanz.Directory, "InstanceSettings.json"); + if (File.Exists(settingsFile)) + { + try + { + config = JsonSerializer.Deserialize( + File.ReadAllText(settingsFile), + new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); + } + catch (Exception ex) + { + logger?.LogError(ex, + "InstanceSettings.json von {Name} ist nicht lesbar — für die Sicherungen " + + "gilt das Standardverzeichnis, nicht das dort eingetragene.", + instanz.Name); + } + } + + return InstanceLayout.ResolveBackupDirectory( + config ?? new InstanceConfig { WorkingDirectory = instanz.Directory }, + instanz.Directory); + } } diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/app.css b/src/ClawdDotNet.Manager.Web/wwwroot/app.css index fe917bb..e378064 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/app.css +++ b/src/ClawdDotNet.Manager.Web/wwwroot/app.css @@ -326,6 +326,33 @@ a:hover { gap: 12px; } +.kopf-instanz-container { + display: flex; + align-items: center; + gap: 8px; +} + +.kopf-instanz-label { + font-size: 13px; + font-weight: 600; + color: var(--gedaempft); +} + +.kopf-instanz-select { + max-width: 220px; + font-weight: 600; + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; +} + +#kopf-instanz-start-btn { + padding: 3px 8px; + font-size: 12px; + font-weight: 600; + white-space: nowrap; +} + .status-punkt { width: 9px; height: 9px; @@ -871,6 +898,46 @@ button.klein { font-weight: 600; } +.log-instanz { + font-family: var(--schrift-mono); + font-size: 11px; + font-weight: 600; + padding: 1px 5px; + background: var(--surface); + border: 1px solid var(--divider); + color: var(--accent); + margin-right: 6px; +} + +/* ─── Ansicht: Instanzen ─── */ + +.instanzen-raster { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); + gap: 20px; + margin-top: 16px; +} + +.instanz-karte { + display: flex; + flex-direction: column; + justify-content: space-between; +} + +.instanz-karte.aktiv { + border-left: 4px solid var(--accent); +} + +.instanz-aktionen { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 8px; + margin-top: 16px; + padding-top: 12px; + border-top: 1px solid var(--divider); +} + /* ─── Modal Dialoge ─── */ .modal-overlay { @@ -987,6 +1054,166 @@ button.klein { overflow-x: auto; } +/* ─── Modale Dialoge ─── */ + +.modal-overlay { + position: fixed; + top: 0; + left: 0; + right: 0; + bottom: 0; + background: rgba(0, 0, 0, 0.65); + backdrop-filter: blur(4px); + display: flex; + align-items: center; + justify-content: center; + z-index: 1500; + padding: 16px; + opacity: 0; + transition: opacity 0.15s ease; + pointer-events: none; +} + +.modal-overlay.sichtbar { + opacity: 1; + pointer-events: auto; +} + +.modal-overlay[hidden] { + display: none; +} + +.modal-box { + max-width: 520px; + width: 100%; + max-height: 90vh; + display: flex; + flex-direction: column; + background: var(--surface); + border: 1px solid var(--divider); + box-shadow: 0 12px 36px rgba(0, 0, 0, 0.35); +} + +.modal-kopf { + display: flex; + align-items: center; + justify-content: space-between; + padding: 14px 18px; + border-bottom: 1px solid var(--divider); + background: var(--surface-subtil); +} + +.modal-kopf h2 { + margin: 0; + font-size: 18px; + font-family: var(--schrift-titel); +} + +.modal-koerper { + padding: 18px; + overflow-y: auto; + display: flex; + flex-direction: column; + gap: 14px; +} + +.modal-fuss { + display: flex; + align-items: center; + justify-content: flex-end; + gap: 10px; + padding: 14px 18px; + border-top: 1px solid var(--divider); + background: var(--surface-subtil); +} + +/* Sicherheits- und Countdown-Elemente */ + +.sicherheits-box { + background: rgba(192, 57, 43, 0.08); + border: 1px solid var(--gefahr); + border-left: 4px solid var(--gefahr); + padding: 12px 16px; + display: flex; + flex-direction: column; + gap: 6px; +} + +.sicherheits-box h3 { + margin: 0; + font-size: 15px; + color: var(--gefahr); + display: flex; + align-items: center; + gap: 8px; +} + +.sicherheits-box p { + margin: 0; + font-size: 13px; + line-height: 1.45; +} + +.sicherheits-countdown { + display: flex; + align-items: center; + justify-content: center; + gap: 8px; + padding: 10px; + background: var(--bg); + border: 1px dashed var(--divider); + font-family: var(--schrift-mono); + font-size: 13px; + font-weight: 600; + color: var(--warnung); + text-align: center; +} + +.sicherheits-countdown.abgelaufen { + color: var(--gefahr); + border-color: var(--gefahr); + border-style: solid; +} + +/* ─── Einstellungen & Systemarchitektur ─── */ + +.einstellungen-ansicht { + display: flex; + flex-direction: column; + gap: 28px; +} + +.einstellungen-sektion { + display: flex; + flex-direction: column; + gap: 14px; + padding: 20px; + background: var(--surface-subtil); + border: 1px solid var(--divider); +} + +.einstellungen-sektion.sektion-manager { + border-left: 4px solid var(--warnung); +} + +.einstellungen-sektion.sektion-instanz { + border-left: 4px solid var(--erfolg); +} + +.sektion-titel-zeile { + display: flex; + align-items: center; + justify-content: space-between; + gap: 12px; + padding-bottom: 8px; + border-bottom: 1px solid var(--divider); +} + +.sektion-titel-zeile h2 { + margin: 0; + font-size: 18px; +} + /* ─── Responsive Optimierung (Handy / 375px) ─── */ @media (max-width: 768px) { @@ -1036,4 +1263,115 @@ button.klein { .chat-aktionen { justify-content: flex-end; } + + .kopf-instanz-label { + display: none; + } + + .kopf-instanz-select { + max-width: 140px; + font-size: 13px; + padding: 4px 6px; + } + + .instanzen-raster { + grid-template-columns: 1fr; + } } + +/* ─── Datensicherung & Wiederherstellung ─── */ + +.sicherung-ansicht { + display: flex; + flex-direction: column; + gap: 16px; +} + +.ordner-pfad-anzeige { + display: flex; + align-items: center; + gap: 8px; + background: var(--surface-subtil); + border: 1px solid var(--divider); + padding: 8px 12px; + margin-top: 8px; + font-family: var(--schrift-mono); + font-size: 13px; + word-break: break-all; +} + +.dateiname-zelle { + display: flex; + align-items: center; + gap: 8px; + word-break: break-all; +} + +.spalte-aktionen { + white-space: nowrap; + text-align: right; +} + +/* ─── Interne Agenten-Kommunikation (A2A) ─── */ + +.agenten-chats-ansicht { + display: flex; + flex-direction: column; + gap: 16px; +} + +.a2a-timeline { + display: flex; + flex-direction: column; + gap: 12px; +} + +.a2a-eintrag { + background: var(--surface); + border: 1px solid var(--divider); + padding: 12px 16px; + display: flex; + flex-direction: column; + gap: 8px; +} + +.a2a-eintrag.a2a-anfrage { + border-left: 3px solid var(--accent); +} + +.a2a-eintrag.a2a-antwort { + border-left: 3px solid var(--erfolg); + background: var(--surface-subtil); +} + +.a2a-eintrag-kopf { + display: flex; + align-items: center; + justify-content: space-between; + gap: 8px; +} + +.a2a-pfeil { + color: var(--gedaempft); + font-weight: 600; + font-size: 13px; +} + +.a2a-zeit { + font-size: 12px; + color: var(--gedaempft); + white-space: nowrap; +} + +.a2a-inhalt { + font-family: var(--schrift-mono); + font-size: 13px; + white-space: pre-wrap; + word-break: break-word; + background: var(--bg); + padding: 10px 12px; + border: 1px solid var(--divider); + margin: 0; + color: var(--text); +} + diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/app.js b/src/ClawdDotNet.Manager.Web/wwwroot/app.js index 864dc9b..556fa99 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/app.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/app.js @@ -1,12 +1,21 @@ // ClawdDotNet — WebUI Haupteinstiegspunkt // -// Initialisiert Authentifizierung, Router, Ereignisstrom, Farbschema und Kopfzeile. +// Initialisiert Authentifizierung, Router, Ereignisstrom, Farbschema, Kopfzeile und Instanzenverwaltung. -import { api, hatToken, loescheToken, beiUnberechtigt } from "./modules/api.js"; +import { + api, + hatToken, + loescheToken, + beiUnberechtigt, + holeAktiveInstanz, + setzeAktiveInstanz, + beiInstanzWechsel +} from "./modules/api.js"; import { verbindeStrom, trenneStrom, beiVerbindungsStatus, abonnieren } from "./modules/events.js"; import { initialisiereTheme, wechsleTheme } from "./modules/theme.js"; import { registriereRoute, initialisiereRouter, navigiere } from "./modules/router.js"; import { initialisiereLogin, zeigeAnmeldung, versteckeAnmeldung } from "./views/login.js"; +import { erstelleElement, erstellePlakette, instanzZustandInfo, zeigeMeldung } from "./modules/dom.js"; // Ansichten import { rendereChat } from "./views/chat.js"; @@ -17,23 +26,33 @@ import { rendereStaging, holeWartendeAnzahl } from "./views/staging.js"; import { rendereVerbrauch } from "./views/usage.js"; import { rendereProtokoll, trenneLogStream } from "./views/logs.js"; import { rendereInfo } from "./views/info.js"; -import { rendereSicherung, rendereEinstellungen, rendereAgentenChats } from "./views/placeholders.js"; +import { rendereInstanzen, stoppePolling as stoppeInstanzenPolling } from "./views/instances.js"; +import { rendereEinstellungen } from "./views/settings.js"; +import { rendereSicherung } from "./views/backup.js"; +import { rendereAgentenChats, trenneAgentenChatsStream } from "./views/agent-chats.js"; // ─── 1. Routen registrieren ─── -registriereRoute("/chat", () => { trenneLogStream(); return rendereChat(); }); -registriereRoute("/chat/:agentId", (p) => { trenneLogStream(); return rendereChat(p); }); -registriereRoute("/agenten", () => { trenneLogStream(); return rendereAgenten(); }); -registriereRoute("/agenten/:agentId", (p) => { trenneLogStream(); return rendereAgenten(p); }); -registriereRoute("/aufgaben", () => { trenneLogStream(); return rendereAufgaben(); }); -registriereRoute("/dienste", () => { trenneLogStream(); return rendereDienste(); }); -registriereRoute("/staging", () => { trenneLogStream(); return rendereStaging(); }); -registriereRoute("/verbrauch", () => { trenneLogStream(); return rendereVerbrauch(); }); -registriereRoute("/agenten-chats", () => { trenneLogStream(); return rendereAgentenChats(); }); -registriereRoute("/protokoll", () => rendereProtokoll()); -registriereRoute("/sicherung", () => { trenneLogStream(); return rendereSicherung(); }); -registriereRoute("/einstellungen", () => { trenneLogStream(); return rendereEinstellungen(); }); -registriereRoute("/info", () => { trenneLogStream(); return rendereInfo(); }); +function verlasseAnsicht() { + trenneLogStream(); + trenneAgentenChatsStream(); + stoppeInstanzenPolling(); +} + +registriereRoute("/instanzen", () => { verlasseAnsicht(); return rendereInstanzen(); }); +registriereRoute("/chat", () => { verlasseAnsicht(); return rendereChat(); }); +registriereRoute("/chat/:agentId", (p) => { verlasseAnsicht(); return rendereChat(p); }); +registriereRoute("/agenten", () => { verlasseAnsicht(); return rendereAgenten(); }); +registriereRoute("/agenten/:agentId", (p) => { verlasseAnsicht(); return rendereAgenten(p); }); +registriereRoute("/aufgaben", () => { verlasseAnsicht(); return rendereAufgaben(); }); +registriereRoute("/dienste", () => { verlasseAnsicht(); return rendereDienste(); }); +registriereRoute("/staging", () => { verlasseAnsicht(); return rendereStaging(); }); +registriereRoute("/verbrauch", () => { verlasseAnsicht(); return rendereVerbrauch(); }); +registriereRoute("/agenten-chats", () => { verlasseAnsicht(); return rendereAgentenChats(); }); +registriereRoute("/protokoll", () => { verlasseAnsicht(); return rendereProtokoll(); }); +registriereRoute("/sicherung", () => { verlasseAnsicht(); return rendereSicherung(); }); +registriereRoute("/einstellungen", () => { verlasseAnsicht(); return rendereEinstellungen(); }); +registriereRoute("/info", () => { verlasseAnsicht(); return rendereInfo(); }); // ─── 2. DOM-Verdrahtung ─── @@ -44,19 +63,30 @@ const seitenleisteBackdrop = document.getElementById("seitenleiste-backdrop"); const themeSchalter = document.getElementById("theme-schalter"); const abmeldenBtn = document.getElementById("abmelden-btn"); const verbindungPunkt = document.getElementById("verbindung-punkt"); -const kopfInstanz = document.getElementById("kopf-instanz"); +let kopfInstanzSelect = document.getElementById("kopf-instanz-select"); +let kopfInstanzStatus = document.getElementById("kopf-instanz-status"); const kopfOpenRouter = document.getElementById("kopf-openrouter-status"); -// Seitenleiste kollabieren (Desktop) -sidebarToggle?.addEventListener("click", () => { - seitenleiste?.classList.toggle("kollabiert"); -}); +let bekannteInstanzen = []; +let instanzenPoller = null; -// Mobil-Menü öffnen -mobilMenueBtn?.addEventListener("click", () => { - seitenleiste?.classList.add("mobil-offen"); - if (seitenleisteBackdrop) seitenleisteBackdrop.hidden = false; -}); +// Seitenleiste ein-/ausklappen (Desktop & Mobil) +function toggleSeitenleiste() { + if (window.innerWidth <= 768) { + const istOffen = seitenleiste?.classList.contains("mobil-offen"); + if (istOffen) { + schliesseMobilMenue(); + } else { + seitenleiste?.classList.add("mobil-offen"); + if (seitenleisteBackdrop) seitenleisteBackdrop.hidden = false; + } + } else { + seitenleiste?.classList.toggle("kollabiert"); + } +} + +sidebarToggle?.addEventListener("click", toggleSeitenleiste); +mobilMenueBtn?.addEventListener("click", toggleSeitenleiste); // Mobil-Menü schließen bei Klick auf Backdrop oder Link function schliesseMobilMenue() { @@ -78,19 +108,27 @@ themeSchalter?.addEventListener("click", () => { // Abmelden abmeldenBtn?.addEventListener("click", () => { + beendeHauptAnwendung(); loescheToken(); - trenneStrom(); - trenneLogStream(); zeigeAnmeldung(); }); // Bei unberechtigtem API-Aufruf (401) sofort zur Anmeldung springen beiUnberechtigt(() => { - trenneStrom(); - trenneLogStream(); + beendeHauptAnwendung(); zeigeAnmeldung(); }); +function beendeHauptAnwendung() { + if (instanzenPoller) { + clearInterval(instanzenPoller); + instanzenPoller = null; + } + trenneStrom(); + trenneLogStream(); + stoppeInstanzenPolling(); +} + // Verbindungsstatus des Ereignisstroms beiVerbindungsStatus((istOffen) => { if (!verbindungPunkt) return; @@ -103,12 +141,148 @@ beiVerbindungsStatus((istOffen) => { } }); +// Instanzwechsel über Dropdown +kopfInstanzSelect?.addEventListener("change", (e) => { + const neueId = e.target.value; + setzeAktiveInstanz(neueId); +}); + +// Bei Instanzwechsel Zustand synchronisieren und Ansicht aktualisieren +beiInstanzWechsel(async (neueId) => { + if (kopfInstanzSelect && kopfInstanzSelect.value !== neueId) { + kopfInstanzSelect.value = neueId; + } + + aktualisiereInstanzPlakette(); + await aktualisiereKopfStatus(); + await aktualisiereStagingZaehler(); + + // Aktuelle Ansicht neu laden, damit die Daten der neuen Instanz geladen werden + if (window.location.hash) { + window.dispatchEvent(new HashChangeEvent("hashchange")); + } +}); + +function aktualisiereInstanzPlakette() { + kopfInstanzStatus = document.getElementById("kopf-instanz-status"); + const startBtn = document.getElementById("kopf-instanz-start-btn"); + + const gewaehlteId = holeAktiveInstanz(); + const aktive = bekannteInstanzen.find((i) => i.id === gewaehlteId); + const laufende = bekannteInstanzen.filter((i) => i.zustand === "Running"); + + if (kopfInstanzStatus) { + if (aktive) { + const zInfo = instanzZustandInfo(aktive.zustand); + const neuePlakette = erstellePlakette(zInfo.text, zInfo.art); + neuePlakette.id = "kopf-instanz-status"; + kopfInstanzStatus.replaceWith(neuePlakette); + kopfInstanzStatus = neuePlakette; + } else { + const text = laufende.length > 1 ? `${laufende.length} laufen` : "Keine aktiv"; + const art = laufende.length > 1 ? "warnung" : "neutral"; + const neuePlakette = erstellePlakette(text, art); + neuePlakette.id = "kopf-instanz-status"; + kopfInstanzStatus.replaceWith(neuePlakette); + kopfInstanzStatus = neuePlakette; + } + } + + if (startBtn) { + if (aktive && aktive.zustand !== "Running") { + startBtn.hidden = false; + startBtn.disabled = false; + startBtn.textContent = "Starten"; + startBtn.onclick = async () => { + startBtn.disabled = true; + startBtn.textContent = "Startet…"; + try { + const res = await api(`/verwaltung/instanzen/${encodeURIComponent(aktive.id)}/start`, { + method: "POST" + }); + zeigeMeldung(res?.meldung || `Instanz '${aktive.name}' gestartet.`, "erfolg"); + await aktualisiereInstanzenListe(); + if (window.location.hash) { + window.dispatchEvent(new HashChangeEvent("hashchange")); + } + } catch (err) { + if (err.lizenzFehlt) { + zeigeMeldung("Start abgelehnt: Ohne gültige Lizenz startet keine Instanz (HTTP 402).", "gefahr", 6000); + } else { + zeigeMeldung(`Start fehlgeschlagen: ${err.message}`, "gefahr"); + } + startBtn.disabled = false; + startBtn.textContent = "Starten"; + } + }; + } else { + startBtn.hidden = true; + } + } +} + +async function aktualisiereInstanzenListe(vorhandene = null) { + try { + bekannteInstanzen = vorhandene || (await api("/verwaltung/instanzen")); + } catch (err) { + if (err.status !== 401) { + console.warn("Konnte Instanzenliste nicht abrufen:", err.message); + } + return; + } + + kopfInstanzSelect = document.getElementById("kopf-instanz-select"); + if (!kopfInstanzSelect) return; + + let gewaehlteId = holeAktiveInstanz(); + const laufende = bekannteInstanzen.filter((i) => i.zustand === "Running"); + + // Automatische Wahl, wenn genau eine Instanz läuft und keine explizit gewählt ist + if (!gewaehlteId && laufende.length === 1) { + gewaehlteId = laufende[0].id; + setzeAktiveInstanz(gewaehlteId); + } else if (gewaehlteId && !bekannteInstanzen.some((i) => i.id === gewaehlteId)) { + if (laufende.length === 1) { + gewaehlteId = laufende[0].id; + setzeAktiveInstanz(gewaehlteId); + } else { + gewaehlteId = ""; + setzeAktiveInstanz(""); + } + } + + // Dropdown neu befüllen + kopfInstanzSelect.replaceChildren(); + const placeholderOpt = erstelleElement("option", { + value: "", + text: bekannteInstanzen.length === 0 ? "Keine Instanzen" : "— Instanz wählen —" + }); + kopfInstanzSelect.append(placeholderOpt); + + for (const instanz of bekannteInstanzen) { + const zInfo = instanzZustandInfo(instanz.zustand); + const opt = erstelleElement("option", { + value: instanz.id, + text: `${instanz.name} (${zInfo.text})` + }); + kopfInstanzSelect.append(opt); + } + + kopfInstanzSelect.value = gewaehlteId || ""; + aktualisiereInstanzPlakette(); +} + // ─── 3. Start & Initialisierung ─── initialisiereTheme(); initialisiereLogin(starteHauptAnwendung); async function aktualisiereKopfStatus() { + if (!holeAktiveInstanz()) { + if (kopfOpenRouter) kopfOpenRouter.textContent = ""; + return; + } + try { const status = await api("/status"); if (kopfOpenRouter && status) { @@ -116,12 +290,26 @@ async function aktualisiereKopfStatus() { ? `OpenRouter: ${status.creditsText}` : (status.isApiReachable ? "OpenRouter: OK" : "OpenRouter: offline"); } - } catch { - if (kopfOpenRouter) kopfOpenRouter.textContent = ""; + } catch (err) { + if (kopfOpenRouter) { + if (err.instanzUnerreichbar) { + kopfOpenRouter.textContent = "Instanz offline (502)"; + } else if (err.instanzKonflikt) { + kopfOpenRouter.textContent = "Instanz wählen (409)"; + } else { + kopfOpenRouter.textContent = ""; + } + } } } async function aktualisiereStagingZaehler() { + if (!holeAktiveInstanz()) { + const badge = document.getElementById("staging-badge"); + if (badge) badge.hidden = true; + return; + } + const anzahl = await holeWartendeAnzahl(); const badge = document.getElementById("staging-badge"); if (badge) { @@ -134,12 +322,17 @@ async function aktualisiereStagingZaehler() { } } -async function starteHauptAnwendung(info) { +async function starteHauptAnwendung(instanzen) { versteckeAnmeldung(); - if (kopfInstanz && info) { - kopfInstanz.textContent = `${info.instanceName} (${info.instanceId})`; - } + // Instanzenliste initialisieren + await aktualisiereInstanzenListe(Array.isArray(instanzen) ? instanzen : null); + + // Hintergrundabgleich der Instanzen alle 5s + if (instanzenPoller) clearInterval(instanzenPoller); + instanzenPoller = setInterval(() => { + aktualisiereInstanzenListe(); + }, 5000); // Ereignisstrom verbinden verbindeStrom(); @@ -165,9 +358,9 @@ async function starteHauptAnwendung(info) { // Prüfe bestehende Session if (hatToken()) { - api("/info") - .then((info) => { - starteHauptAnwendung(info); + api("/verwaltung/instanzen") + .then((instanzen) => { + starteHauptAnwendung(instanzen); }) .catch(() => { loescheToken(); diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/index.html b/src/ClawdDotNet.Manager.Web/wwwroot/index.html index ec7548c..ce9a013 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/index.html +++ b/src/ClawdDotNet.Manager.Web/wwwroot/index.html @@ -15,7 +15,7 @@

ClawdDotNet

- Bitte gib das Zugangstoken der Instanz ein (webUiToken in der Instanzdatei). + Bitte gib das Zugangstoken des Instanzmanagers ein (webUiToken in manager.json).

@@ -87,6 +87,12 @@
System
+ + + + + Instanzen + @@ -129,14 +135,21 @@
- - +
+ + + Lädt… + +
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/modules/api.js b/src/ClawdDotNet.Manager.Web/wwwroot/modules/api.js index cba64af..e26d932 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/modules/api.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/modules/api.js @@ -3,9 +3,12 @@ // Verwaltet das Zugangstoken im sessionStorage und kapselt fetch-Aufrufe. export const TOKEN_SCHLUESSEL = "clawd.token"; +export const INSTANZ_SCHLUESSEL = "clawd.instanz"; let token = sessionStorage.getItem(TOKEN_SCHLUESSEL) ?? ""; +let aktiveInstanz = sessionStorage.getItem(INSTANZ_SCHLUESSEL) ?? ""; const unberechtigtCallbacks = new Set(); +const instanzWechselCallbacks = new Set(); /** * Gibt das aktuell gespeicherte Token zurück. @@ -29,11 +32,58 @@ export function setzeToken(neuesToken) { } /** - * Löscht das Token (Abmeldung). + * Löscht das Token und die aktive Instanz (Abmeldung). */ export function loescheToken() { token = ""; sessionStorage.removeItem(TOKEN_SCHLUESSEL); + loescheAktiveInstanz(); +} + +/** + * Gibt die aktuell ausgewählte Instanz-ID zurück. + * @returns {string} + */ +export function holeAktiveInstanz() { + return aktiveInstanz; +} + +/** + * Speichert die aktive Instanz im Speicher und sessionStorage. + * @param {string} neueInstanzId + */ +export function setzeAktiveInstanz(neueInstanzId) { + const id = (neueInstanzId || "").trim(); + if (aktiveInstanz === id) return; + aktiveInstanz = id; + if (aktiveInstanz) { + sessionStorage.setItem(INSTANZ_SCHLUESSEL, aktiveInstanz); + } else { + sessionStorage.removeItem(INSTANZ_SCHLUESSEL); + } + for (const cb of instanzWechselCallbacks) { + try { + cb(aktiveInstanz); + } catch (err) { + console.error("Fehler im InstanzWechsel-Callback:", err); + } + } +} + +/** + * Entfernt die aktive Instanz. + */ +export function loescheAktiveInstanz() { + setzeAktiveInstanz(""); +} + +/** + * Registriert einen Rückruf für Instanzwechsel. + * @param {(instanzId: string) => void} callback + */ +export function beiInstanzWechsel(callback) { + instanzWechselCallbacks.add(callback); + return () => instanzWechselCallbacks.delete(callback); } /** @@ -66,6 +116,7 @@ function meldeUnberechtigt() { /** * Führt einen Aufruf gegen die API aus. + * Sendet bei gesetzter aktiver Instanz automatisch die X-Instanz-Kopfzeile mit. * @param {string} pfad Pfad relativ zu /api, z.B. "/info" oder "/agents" * @param {RequestInit} [optionen={}] * @returns {Promise} @@ -76,6 +127,10 @@ export async function api(pfad, optionen = {}) { Authorization: `Bearer ${token}` }; + if (aktiveInstanz && !kopfzeilen["X-Instanz"] && !pfad.startsWith("/verwaltung")) { + kopfzeilen["X-Instanz"] = aktiveInstanz; + } + if (optionen.body && typeof optionen.body === "object" && !(optionen.body instanceof FormData)) { kopfzeilen["Content-Type"] = "application/json"; optionen.body = JSON.stringify(optionen.body); @@ -98,12 +153,15 @@ export async function api(pfad, optionen = {}) { let meldung = `HTTP ${antwort.status}`; try { const rumpf = await antwort.json(); - meldung = rumpf?.message ?? rumpf?.fehler ?? rumpf?.detail ?? meldung; + meldung = rumpf?.message ?? rumpf?.meldung ?? rumpf?.fehler ?? rumpf?.detail ?? meldung; } catch { // Wenn kein JSON geliefert wird, bleibt es beim HTTP-Code } const fehler = new Error(meldung); fehler.status = antwort.status; + if (antwort.status === 402) fehler.lizenzFehlt = true; + if (antwort.status === 409) fehler.instanzKonflikt = true; + if (antwort.status === 502) fehler.instanzUnerreichbar = true; throw fehler; } diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/modules/dom.js b/src/ClawdDotNet.Manager.Web/wwwroot/modules/dom.js index e141e92..90da2d4 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/modules/dom.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/modules/dom.js @@ -109,9 +109,33 @@ export const PFADE = { pfeilUnten: "M6 9l6 6 6-6", haken: "M20 6L9 17l-5-5", ausrufezeichen: "M12 8v4 M12 16h.01 M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20z", - ausloggen: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4 M16 17l5-5-5-5 M21 12H9" + ausloggen: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4 M16 17l5-5-5-5 M21 12H9", + server: "M2 20h20 M2 14h20 M2 8h20 M2 4h20 M6 6h.01 M6 12h.01 M6 18h.01", + fenster: "M3 3h18v18H3z M3 9h18 M9 21V9", + stop: "M6 6h12v12H6z" }; +/** + * Übersetzt den technischen Instanzzustand in deutschen Text und Plakettenstil. + * @param {string} zustand "Running"|"Stopped"|"Silent"|"Crashed"|"Unknown" + * @returns {{ text: string, art: "erfolg"|"warnung"|"gefahr"|"neutral" }} + */ +export function instanzZustandInfo(zustand) { + const z = (zustand || "").toLowerCase(); + switch (z) { + case "running": + return { text: "Läuft", art: "erfolg" }; + case "stopped": + return { text: "Beendet", art: "neutral" }; + case "silent": + return { text: "Verstummt", art: "warnung" }; + case "crashed": + return { text: "Abgestürzt", art: "gefahr" }; + default: + return { text: zustand || "Unbekannt", art: "neutral" }; + } +} + /** * Erzeugt eine Statusplakette (Badge). * @param {string} text @@ -154,11 +178,12 @@ export function erstelleKarte(titel, elemente = [], optionen = {}) { * @param {string} titel * @param {HTMLElement} inhalt * @param {HTMLElement[]} [aktionen] + * @param {object} [optionen] * @returns {{ dialog: HTMLElement, oeffnen: () => void, schliessen: () => void }} */ -export function erstelleModal(titel, inhalt, aktionen = []) { +export function erstelleModal(titel, inhalt, aktionen = [], optionen = {}) { const overlay = erstelleElement("div", { klasse: "modal-overlay", hidden: true }); - const box = erstelleElement("div", { klasse: "modal-box karte" }); + const box = erstelleElement("div", { klasse: `modal-box karte ${optionen.klasse ?? ""}`.trim() }); const kopf = erstelleElement("div", { klasse: "modal-kopf" }); const h = erstelleElement("h2", { text: titel }); @@ -172,16 +197,33 @@ export function erstelleModal(titel, inhalt, aktionen = []) { const koerper = erstelleElement("div", { klasse: "modal-koerper" }, inhalt); const fuss = erstelleElement("div", { klasse: "modal-fuss" }); - for (const aktion of aktionen) fuss.append(aktion); + + // Wenn der Inhalt ein Formular ist oder enthält, verknüpfe Submit-Buttons im Fuß + const formElement = (inhalt && inhalt.tagName === "FORM") + ? inhalt + : (inhalt?.querySelector ? inhalt.querySelector("form") : null); + + for (const aktion of aktionen) { + if (formElement && (aktion.type === "submit" || aktion.getAttribute?.("type") === "submit")) { + aktion.addEventListener("click", () => { + formElement.requestSubmit(); + }); + } + fuss.append(aktion); + } box.append(kopf, koerper, fuss); overlay.append(box); document.body.append(overlay); const schliessen = () => { + if (overlay.hidden) return; overlay.hidden = true; overlay.classList.remove("sichtbar"); document.removeEventListener("keydown", tasteHandler); + if (typeof optionen.onSchliessen === "function") { + optionen.onSchliessen(); + } }; const oeffnen = () => { diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js new file mode 100644 index 0000000..65d437d --- /dev/null +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js @@ -0,0 +1,274 @@ +// ClawdDotNet — Interne Agenten-Kommunikation A2A (Vorhaben #208) +// +// Analyse und Protokollierung des Nachrichtenaustauschs zwischen Agenten. +// - Filterbar nach beteiligten Agenten +// - Dialog-Timeline zwischen Quelle und Ziel +// - Live-Aktualisierung über Server-Sent Events (SSE "chat" mit source === "agentcomm") +// Strikt DOM API, kein innerHTML. + +import { api, holeAktiveInstanz } from "../modules/api.js"; +import { abonnieren } from "../modules/events.js"; +import { + erstelleElement, + erstelleKarte, + erstellePlakette, + erstelleIcon, + PFADE, + formatiereDatumZeit +} from "../modules/dom.js"; + +let sseAbmeldung = null; + +export async function rendereAgentenChats() { + const container = document.getElementById("ansicht-inhalt"); + if (!container) return; + container.replaceChildren(); + + if (sseAbmeldung) { + sseAbmeldung(); + sseAbmeldung = null; + } + + const instanzId = holeAktiveInstanz(); + const layout = erstelleElement("div", { klasse: "agenten-chats-ansicht" }); + + // Kopfzeile + const kopf = erstelleElement("div", { klasse: "ansicht-kopf" }); + const titelGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + titelGruppe.append( + erstelleElement("h1", { text: "Agenten-Kommunikation (A2A)" }) + ); + + const filterGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + + const agentSelect = erstelleElement("select", { + klasse: "eingabe", + stil: { minWidth: "180px" }, + title: "Nach Agent filtern" + }); + const optAlle = erstelleElement("option", { value: "", text: "Alle Agenten" }); + agentSelect.append(optAlle); + + const aktualisierenBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche flach", + title: "Kommunikation neu laden", + onclick: () => ladeVerlauf() + }, + erstelleIcon(PFADE.aktualisieren, 16), + erstelleElement("span", { text: " Aktualisieren" }) + ); + + filterGruppe.append(agentSelect, aktualisierenBtn); + kopf.append(titelGruppe, filterGruppe); + layout.append(kopf); + + if (!instanzId) { + layout.append( + erstelleKarte("Keine Instanz ausgewählt", [ + erstelleElement("p", { + klasse: "hinweis", + text: "Bitte wähle oben im Kopfbereich eine Instanz aus, um deren Agenten-Kommunikation anzuzeigen." + }) + ]) + ); + container.append(layout); + return; + } + + // Infokarte + const infoKarte = erstelleKarte("Interne Kommunikation", [ + erstelleElement("p", { + klasse: "gedaempft", + text: "Hier wird der direkte Nachrichtenaustausch zwischen Agenten (A2A) protokolliert, wenn Agenten über das Werkzeug 'SendMessage' miteinander interagieren." + }) + ]); + layout.append(infoKarte); + + // Verlauf-Container + const verlaufContainer = erstelleElement("div", { klasse: "a2a-timeline" }); + layout.append(verlaufContainer); + container.append(layout); + + let alleNachrichten = []; + let agentenListe = []; + + // Agenten laden für Filter + try { + const agenten = await api("/agents"); + agentenListe = Array.isArray(agenten) ? agenten : []; + for (const a of agentenListe) { + const opt = erstelleElement("option", { + value: a.agentId, + text: a.displayName || a.agentId + }); + agentSelect.append(opt); + } + } catch { + // Wenn Agenten nicht ladbar sind, Filter leer lassen + } + + agentSelect.addEventListener("change", () => { + rendereNachrichten(); + }); + + async function ladeVerlauf() { + verlaufContainer.replaceChildren( + erstelleElement("div", { klasse: "hinweis-zentriert", text: "Lade Kommunikationsverlauf…" }) + ); + + try { + const daten = await api("/agents/communications"); + alleNachrichten = Array.isArray(daten) ? daten : []; + rendereNachrichten(); + } catch (err) { + verlaufContainer.replaceChildren( + erstelleKarte("Fehler", [ + erstelleElement("p", { + klasse: "fehler-meldung", + text: `Kommunikation konnte nicht geladen werden: ${err.message}` + }) + ]) + ); + } + } + + function rendereNachrichten() { + const gewaehlterAgent = agentSelect.value; + const gefiltert = gewaehlterAgent + ? alleNachrichten.filter( + (m) => + m.targetAgentId === gewaehlterAgent || + m.sourceAgentId === gewaehlterAgent + ) + : alleNachrichten; + + if (gefiltert.length === 0) { + verlaufContainer.replaceChildren( + erstelleKarte("Keine Nachrichten", [ + erstelleElement("p", { + klasse: "gedaempft", + text: gewaehlterAgent + ? "Für den ausgewählten Agenten liegt noch keine interne Kommunikation vor." + : "In dieser Instanz wurde bisher keine interne Agent-zu-Agent-Kommunikation protokolliert." + }) + ]) + ); + return; + } + + verlaufContainer.replaceChildren(); + + for (const m of gefiltert) { + const eintrag = erstelleNachrichtElement(m); + verlaufContainer.append(eintrag); + } + } + + function erstelleNachrichtElement(m) { + const istAntwort = m.role === "assistant"; + const kasten = erstelleElement("div", { + klasse: `a2a-eintrag ${istAntwort ? "a2a-antwort" : "a2a-anfrage"}` + }); + + const kopf = erstelleElement("div", { klasse: "a2a-eintrag-kopf" }); + const absenderGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + + if (istAntwort) { + // Antwort vom Zielagenten + absenderGruppe.append( + erstellePlakette(m.targetAgentName || m.targetAgentId, "erfolg"), + erstelleElement("span", { klasse: "a2a-pfeil", text: "➔ Antwort" }) + ); + } else { + // Anfrage/Nachricht von Quelle an Ziel + const quelleName = m.sourceAgentName || m.sourceAgentId || "Agent"; + const zielName = m.targetAgentName || m.targetAgentId; + absenderGruppe.append( + erstellePlakette(quelleName, "neutral"), + erstelleElement("span", { klasse: "a2a-pfeil", text: "➔" }), + erstellePlakette(zielName, "primaer") + ); + } + + const zeit = erstelleElement("span", { + klasse: "a2a-zeit", + text: formatiereDatumZeit(m.timestamp) + }); + + kopf.append(absenderGruppe, zeit); + + const inhalt = erstelleElement("pre", { + klasse: "a2a-inhalt", + text: m.content + }); + + kasten.append(kopf, inhalt); + return kasten; + } + + // SSE Live-Aktualisierung + sseAbmeldung = abonnieren("chat", (daten) => { + if (daten?.source === "agentcomm") { + // Neue Nachricht kam live herein: an die Liste anhängen + const zielAgent = agentenListe.find((a) => a.agentId === daten.agentId); + const zielName = zielAgent ? zielAgent.displayName : daten.agentId; + + let senderId = null; + let senderName = null; + let content = daten.content || ""; + + if (daten.role === "user" && content.startsWith("[Nachricht von Agent \"")) { + const endQuote = content.indexOf('"', 22); + if (endQuote > 22) { + senderName = content.slice(22, endQuote); + const openParen = content.indexOf("(", endQuote); + const closeParen = content.indexOf(")", openParen); + if (openParen > 0 && closeParen > openParen) { + senderId = content.slice(openParen + 1, closeParen); + } + } + const doubleNl = content.indexOf("\n\n"); + if (doubleNl > 0) { + content = content.slice(doubleNl + 2); + } + } + + const neueNachricht = { + targetAgentId: daten.agentId, + targetAgentName: zielName, + sourceAgentId: senderId, + sourceAgentName: senderName, + role: daten.role, + content: content, + timestamp: daten.timestamp || new Date().toISOString() + }; + + alleNachrichten.push(neueNachricht); + + const gewaehlterAgent = agentSelect.value; + if ( + !gewaehlterAgent || + neueNachricht.targetAgentId === gewaehlterAgent || + neueNachricht.sourceAgentId === gewaehlterAgent + ) { + // Falls vorher "Keine Nachrichten" da stand: + const leerKarte = verlaufContainer.querySelector(".karte"); + if (leerKarte) verlaufContainer.replaceChildren(); + + const el = erstelleNachrichtElement(neueNachricht); + verlaufContainer.append(el); + } + } + }); + + ladeVerlauf(); +} + +export function trenneAgentenChatsStream() { + if (sseAbmeldung) { + sseAbmeldung(); + sseAbmeldung = null; + } +} diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js index 6a2d545..af4e0d7 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js @@ -74,12 +74,16 @@ async function ladeUndRendereListe(zielId = null) { listeContainer.replaceChildren(); if (!agenten || agenten.length === 0) { - listeContainer.append( - erstelleElement("div", { - klasse: "hinweis-zentriert", - text: "Keine Agenten eingerichtet." - }) + const leerKasten = erstelleElement("div", { klasse: "hinweis-zentriert" }); + leerKasten.append( + erstelleElement("p", { klasse: "gedaempft", text: "In dieser Instanz sind noch keine Agenten eingerichtet." }), + erstelleElement("button", { + klasse: "schaltflaeche primaer klein", + onclick: oeffneNeuerAgentDialog, + style: "margin-top: 10px;" + }, erstelleIcon(PFADE.plus, 14), erstelleElement("span", { text: " Ersten Agenten anlegen" })) ); + listeContainer.append(leerKasten); rendereDetails(null); return; } @@ -123,8 +127,13 @@ async function ladeUndRendereListe(zielId = null) { rendereDetails(auswahlId); } catch (err) { + const text = err.instanzUnerreichbar + ? "Die ausgewählte Instanz läuft derzeit nicht. Bitte starte sie zuerst im Kopfbereich oder unter 'Instanzen'." + : (err.instanzKonflikt + ? "Keine aktive Instanz gewählt. Bitte wähle oben eine Instanz aus." + : err.message); listeContainer.replaceChildren( - erstelleElement("div", { klasse: "fehler-zentriert", text: err.message }) + erstelleElement("div", { klasse: "fehler-zentriert", text }) ); } } @@ -260,7 +269,10 @@ async function rendereDetails(agentId) { } function oeffneNeuerAgentDialog() { - const formular = erstelleElement("form", { klasse: "formular-raster" }); + const formular = erstelleElement("form", { + klasse: "formular-raster", + id: "neuer-agent-formular" + }); const idFeld = erstelleElement("input", { type: "text", @@ -315,7 +327,11 @@ function oeffneNeuerAgentDialog() { "button", { type: "submit", - klasse: "schaltflaeche primaer" + klasse: "schaltflaeche primaer", + form: "neuer-agent-formular", + onclick: () => { + formular.requestSubmit(); + } }, erstelleElement("span", { text: "Agent anlegen" }) ); diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/backup.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/backup.js new file mode 100644 index 0000000..4aa77ce --- /dev/null +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/backup.js @@ -0,0 +1,426 @@ +// ClawdDotNet — Datensicherung & Wiederherstellung (Vorhaben #530, Stufe 6) +// +// Verwaltet Sicherungen (.zip) der aktiven Instanz: +// - Auflistung aller Archive im Sicherungsverzeichnis +// - Neue Sicherung anlegen (Passphrase-Schutz, Logs, Chatverlauf) +// - Wiederherstellung (mit geordnetem Stop/Start der Instanz) +// - Löschen von Archiven +// Strikt DOM API, kein innerHTML. + +import { api, holeAktiveInstanz } from "../modules/api.js"; +import { + erstelleElement, + erstelleKarte, + erstellePlakette, + erstelleIcon, + erstelleModal, + PFADE, + formatiereDatumZeit, + zeigeMeldung +} from "../modules/dom.js"; + +function formatiereBytes(bytes) { + if (bytes === 0) return "0 B"; + if (!bytes) return "—"; + const k = 1024; + const sizes = ["B", "KB", "MB", "GB"]; + const i = Math.floor(Math.log(bytes) / Math.log(k)); + return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i]; +} + +export async function rendereSicherung() { + const container = document.getElementById("ansicht-inhalt"); + if (!container) return; + container.replaceChildren(); + + const instanzId = holeAktiveInstanz(); + const layout = erstelleElement("div", { klasse: "sicherung-ansicht" }); + + // Kopfzeile + const kopf = erstelleElement("div", { klasse: "ansicht-kopf" }); + const titelGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + titelGruppe.append(erstelleElement("h1", { text: "Datensicherung & Wiederherstellung" })); + + const aktionenGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + + const aktualisierenBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche flach", + title: "Sicherungen neu laden", + onclick: () => ladeSicherungen() + }, + erstelleIcon(PFADE.aktualisieren, 16), + erstelleElement("span", { text: " Aktualisieren" }) + ); + + const neuBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche primaer", + title: "Neue Sicherung erstellen", + disabled: !instanzId, + onclick: () => oeffneSicherungsDialog() + }, + erstelleIcon(PFADE.plus, 16), + erstelleElement("span", { text: " Neue Sicherung" }) + ); + + aktionenGruppe.append(aktualisierenBtn, neuBtn); + kopf.append(titelGruppe, aktionenGruppe); + layout.append(kopf); + + if (!instanzId) { + layout.append( + erstelleKarte("Keine Instanz ausgewählt", [ + erstelleElement("p", { + klasse: "hinweis", + text: "Bitte wähle oben im Kopfbereich eine Instanz aus, um deren Sicherungen zu verwalten." + }) + ]) + ); + container.append(layout); + return; + } + + // Verzeichnis-Info & Inhalt + const infoBereich = erstelleElement("div", { klasse: "sicherung-info-bereich" }); + const inhaltBereich = erstelleElement("div", { klasse: "sicherung-inhalt-bereich" }); + + layout.append(infoBereich, inhaltBereich); + container.append(layout); + + async function ladeSicherungen() { + inhaltBereich.replaceChildren( + erstelleElement("div", { klasse: "hinweis-zentriert", text: "Lade Sicherungen…" }) + ); + + try { + const daten = await api(`/verwaltung/instanzen/${instanzId}/backups`); + const verzeichnis = daten?.directory ?? "—"; + const backups = daten?.backups ?? []; + + infoBereich.replaceChildren( + erstelleKarte("Sicherungsverzeichnis", [ + erstelleElement("p", { klasse: "gedaempft", text: "Sicherungen werden komprimiert als ZIP-Archiv abgelegt. Die Datenbank (state.db) wird konsistent per VACUUM INTO kopiert." }), + erstelleElement("div", { klasse: "ordner-pfad-anzeige" }, + erstelleIcon(PFADE.server, 14), + erstelleElement("code", { text: verzeichnis }) + ) + ]) + ); + + if (backups.length === 0) { + inhaltBereich.replaceChildren( + erstelleKarte("Vorhandene Sicherungen", [ + erstelleElement("p", { + klasse: "gedaempft", + text: "Für diese Instanz sind noch keine Sicherungsarchive vorhanden. Erstelle über die Schaltfläche oben eine neue Sicherung." + }) + ]) + ); + return; + } + + const tabelle = erstelleElement("table", { klasse: "tabelle sicherungen-tabelle" }); + const thead = erstelleElement("thead", {}, + erstelleElement("tr", {}, + erstelleElement("th", { text: "Archivdatei" }), + erstelleElement("th", { text: "Erstellt am" }), + erstelleElement("th", { text: "Größe" }), + erstelleElement("th", { text: "Zugangsdaten" }), + erstelleElement("th", { text: "Dateien" }), + erstelleElement("th", { klasse: "spalte-aktionen", text: "Aktionen" }) + ) + ); + + const tbody = erstelleElement("tbody"); + + for (const b of backups) { + const tr = erstelleElement("tr"); + + // Dateiname & Icon + const dateiTd = erstelleElement("td", { klasse: "dateiname-zelle" }, + erstelleIcon(PFADE.sicherung, 16), + erstelleElement("strong", { text: b.fileName }) + ); + + // Datum + const datumTd = erstelleElement("td", { text: formatiereDatumZeit(b.createdAt) }); + + // Größe + const groesseTd = erstelleElement("td", { text: formatiereBytes(b.sizeBytes) }); + + // Zugangsdaten Modus + const hatPassphrase = b.secrets === "Passphrase"; + const secretsPlakette = erstellePlakette( + hatPassphrase ? `Passphrase (${b.secretCount})` : "Ausgeschlossen", + hatPassphrase ? "erfolg" : "neutral" + ); + const secretsTd = erstelleElement("td", {}, secretsPlakette); + + // Dateienanzahl + const dateienTd = erstelleElement("td", { text: b.fileCount > 0 ? `${b.fileCount} Dateien` : "—" }); + + // Aktionen + const aktionenTd = erstelleElement("td", { klasse: "spalte-aktionen" }); + + const restoreBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche klein sekundär", + title: "Diese Sicherung wiederherstellen", + onclick: () => oeffneRestoreDialog(b) + }, + erstelleIcon(PFADE.abspielen, 14), + erstelleElement("span", { text: " Wiederherstellen" }) + ); + + const deleteBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche klein gefahr flach", + title: "Sicherungsdatei unwiderruflich löschen", + onclick: () => oeffneLoeschenDialog(b.fileName) + }, + erstelleIcon(PFADE.muelleimer, 14) + ); + + aktionenTd.append(restoreBtn, deleteBtn); + tr.append(dateiTd, datumTd, groesseTd, secretsTd, dateienTd, aktionenTd); + tbody.append(tr); + } + + tabelle.append(thead, tbody); + inhaltBereich.replaceChildren( + erstelleKarte(`Vorhandene Sicherungen (${backups.length})`, [tabelle]) + ); + } catch (err) { + inhaltBereich.replaceChildren( + erstelleKarte("Fehler", [ + erstelleElement("p", { klasse: "fehler-meldung", text: `Sicherungen konnten nicht geladen werden: ${err.message}` }) + ]) + ); + } + } + + // ─── Modal: Neue Sicherung erstellen ─── + function oeffneSicherungsDialog() { + const form = erstelleElement("form", { klasse: "formular" }); + + // Modus Zugangsdaten + const secretsGruppe = erstelleElement("div", { klasse: "form-gruppe" }); + secretsGruppe.append( + erstelleElement("label", { text: "Zugangsdaten & Schlüssel" }), + erstelleElement("p", { klasse: "form-hilfe", text: "DPAPI-geschützte Daten können mit einer Passphrase geschützt oder sicherheitshalber entfernt werden." }) + ); + + const secretsSelect = erstelleElement("select", { klasse: "eingabe" }); + const optExclude = erstelleElement("option", { value: "Exclude", text: "Entfernen (gefahrlos ablegbar, Schlüssel müssen neu eingetragen werden)" }); + const optPassphrase = erstelleElement("option", { value: "Passphrase", text: "Mit Passphrase schützen (vollständig übertragbar)" }); + secretsSelect.append(optExclude, optPassphrase); + secretsGruppe.append(secretsSelect); + + // Passphrase Feld + const passGruppe = erstelleElement("div", { klasse: "form-gruppe", stil: { display: "none" } }); + const passInput = erstelleElement("input", { + type: "password", + klasse: "eingabe", + placeholder: "Passphrase für Verschlüsselung eingeben…" + }); + passGruppe.append( + erstelleElement("label", { text: "Passphrase" }), + passInput + ); + + secretsSelect.addEventListener("change", () => { + passGruppe.style.display = secretsSelect.value === "Passphrase" ? "block" : "none"; + if (secretsSelect.value === "Passphrase") passInput.focus(); + }); + + // Checkboxen + const chatsGruppe = erstelleElement("div", { klasse: "form-gruppe-checkbox" }); + const chatsCheckbox = erstelleElement("input", { type: "checkbox", id: "backup-chk-chats", checked: true }); + const chatsLabel = erstelleElement("label", { for: "backup-chk-chats", text: "Chatverläufe sichern" }); + chatsGruppe.append(chatsCheckbox, chatsLabel); + + const logsGruppe = erstelleElement("div", { klasse: "form-gruppe-checkbox" }); + const logsCheckbox = erstelleElement("input", { type: "checkbox", id: "backup-chk-logs", checked: false }); + const logsLabel = erstelleElement("label", { for: "backup-chk-logs", text: "Protokolldateien (Logs) einschließen" }); + logsGruppe.append(logsCheckbox, logsLabel); + + form.append(secretsGruppe, passGruppe, chatsGruppe, logsGruppe); + + let modal; + const abbrechenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche", + text: "Abbrechen", + onclick: () => modal.schliessen() + }); + + const speichernBtn = erstelleElement("button", { + type: "submit", + klasse: "schaltflaeche primaer", + text: "Sicherung erstellen" + }); + + form.addEventListener("submit", async (e) => { + e.preventDefault(); + const secrets = secretsSelect.value; + const passphrase = passInput.value.trim(); + + if (secrets === "Passphrase" && !passphrase) { + zeigeMeldung("Bitte gib eine Passphrase ein.", "warnung"); + passInput.focus(); + return; + } + + speichernBtn.disabled = true; + speichernBtn.textContent = "Erstelle Sicherung…"; + + try { + const res = await api(`/verwaltung/instanzen/${instanzId}/backups`, { + method: "POST", + body: { + secrets, + passphrase: passphrase || null, + includeLogs: logsCheckbox.checked, + includeChatHistory: chatsCheckbox.checked + } + }); + zeigeMeldung(res.meldung || "Sicherung erfolgreich erstellt.", "erfolg"); + modal.schliessen(); + ladeSicherungen(); + } catch (err) { + zeigeMeldung(`Fehler beim Sichern: ${err.message}`, "gefahr"); + speichernBtn.disabled = false; + speichernBtn.textContent = "Sicherung erstellen"; + } + }); + + modal = erstelleModal("Neue Sicherung erstellen", form, [abbrechenBtn, speichernBtn]); + modal.oeffnen(); + } + + // ─── Modal: Wiederherstellen ─── + function oeffneRestoreDialog(backup) { + const form = erstelleElement("form", { klasse: "formular" }); + + const warnung = erstelleElement("div", { klasse: "hinweis-box warnung" }, + erstelleIcon(PFADE.ausrufezeichen, 18), + erstelleElement("div", {}, + erstelleElement("strong", { text: "Achtung: Überschreiben bestehender Daten" }), + erstelleElement("p", { + text: `Die Wiederherstellung überschreibt die aktuellen Konfigurationen und Daten der Instanz mit dem Stand vom ${formatiereDatumZeit(backup.createdAt)}.` + }), + erstelleElement("p", { + text: "Die Instanz wird dafür kurz geordnet gestoppt und nach erfolgreicher Rücksicherung wieder hochgefahren." + }) + ) + ); + + form.append(warnung); + + let passInput = null; + if (backup.secrets === "Passphrase") { + const passGruppe = erstelleElement("div", { klasse: "form-gruppe", stil: { marginTop: "16px" } }); + passInput = erstelleElement("input", { + type: "password", + klasse: "eingabe", + placeholder: "Passphrase der Sicherung eingeben…", + required: true + }); + passGruppe.append( + erstelleElement("label", { text: "Passphrase für Zugangsdaten" }), + passInput + ); + form.append(passGruppe); + } + + let modal; + const abbrechenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche", + text: "Abbrechen", + onclick: () => modal.schliessen() + }); + + const restoreBtn = erstelleElement("button", { + type: "submit", + klasse: "schaltflaeche warnung", + text: "Jetzt Wiederherstellen" + }); + + form.addEventListener("submit", async (e) => { + e.preventDefault(); + const passphrase = passInput?.value?.trim() || null; + + if (backup.secrets === "Passphrase" && !passphrase) { + zeigeMeldung("Bitte gib die Passphrase an.", "warnung"); + passInput?.focus(); + return; + } + + restoreBtn.disabled = true; + restoreBtn.textContent = "Stelle wieder her…"; + + try { + const res = await api(`/verwaltung/instanzen/${instanzId}/backups/${encodeURIComponent(backup.fileName)}/restore`, { + method: "POST", + body: { passphrase } + }); + zeigeMeldung(res.meldung || "Wiederherstellung erfolgreich abgeschlossen.", "erfolg"); + modal.schliessen(); + ladeSicherungen(); + } catch (err) { + zeigeMeldung(`Wiederherstellung fehlgeschlagen: ${err.message}`, "gefahr"); + restoreBtn.disabled = false; + restoreBtn.textContent = "Jetzt Wiederherstellen"; + } + }); + + modal = erstelleModal(`Sicherung wiederherstellen: ${backup.fileName}`, form, [abbrechenBtn, restoreBtn]); + modal.oeffnen(); + } + + // ─── Modal: Löschen ─── + function oeffneLoeschenDialog(fileName) { + const text = erstelleElement("p", { + text: `Soll die Sicherungsdatei '${fileName}' wirklich unwiderruflich gelöscht werden?` + }); + + let modal; + const abbrechenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche", + text: "Abbrechen", + onclick: () => modal.schliessen() + }); + + const loeschenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche gefahr", + text: "Löschen", + onclick: async () => { + loeschenBtn.disabled = true; + try { + const res = await api(`/verwaltung/instanzen/${instanzId}/backups/${encodeURIComponent(fileName)}`, { + method: "DELETE" + }); + zeigeMeldung(res.meldung || "Sicherung gelöscht.", "erfolg"); + modal.schliessen(); + ladeSicherungen(); + } catch (err) { + zeigeMeldung(`Löschen fehlgeschlagen: ${err.message}`, "gefahr"); + loeschenBtn.disabled = false; + } + } + }); + + modal = erstelleModal("Sicherung löschen", text, [abbrechenBtn, loeschenBtn]); + modal.oeffnen(); + } + + ladeSicherungen(); +} diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js index ffc3bab..3f56946 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js @@ -2,7 +2,7 @@ // // Leitfaden: Sicherer Chatverlauf (strikt textContent), Echtzeit-Ereignisse über SSE. -import { api } from "../modules/api.js"; +import { api, holeAktiveInstanz } from "../modules/api.js"; import { abonnieren } from "../modules/events.js"; import { erstelleElement, @@ -131,7 +131,8 @@ export async function rendereChat(parameter = {}) { // SSE-Abonnements entladeEreignisse.push( abonnieren("chat", (daten) => { - if (daten.agentId === aktiverAgentId) { + const aktiveId = holeAktiveInstanz(); + if (daten.agentId === aktiverAgentId && (!daten.instanz || !aktiveId || daten.instanz === aktiveId)) { fuegeNachrichtEin(daten); } }) @@ -139,7 +140,8 @@ export async function rendereChat(parameter = {}) { entladeEreignisse.push( abonnieren("step", (daten) => { - if (daten.agentId === aktiverAgentId) { + const aktiveId = holeAktiveInstanz(); + if (daten.agentId === aktiverAgentId && (!daten.instanz || !aktiveId || daten.instanz === aktiveId)) { zeigeSchritt(daten.text); } }) @@ -147,14 +149,18 @@ export async function rendereChat(parameter = {}) { entladeEreignisse.push( abonnieren("run", (daten) => { - versteckeSchritt(); - aktualisiereLaufStatus(false); + const aktiveId = holeAktiveInstanz(); + if (!daten.instanz || !aktiveId || daten.instanz === aktiveId) { + versteckeSchritt(); + aktualisiereLaufStatus(false); + } }) ); entladeEreignisse.push( abonnieren("instance", (daten) => { - if (daten.kind === "Agents") { + const aktiveId = holeAktiveInstanz(); + if (daten.kind === "Agents" && (!daten.instanz || !aktiveId || daten.instanz === aktiveId)) { ladeAgenten(aktiverAgentId); } }) @@ -286,6 +292,10 @@ function fuegeNachrichtEin(eintrag) { }); kopf.append(autor); + if (eintrag.instanzName) { + const instanzBadge = erstelleElement("span", { klasse: "quelle-tag", text: eintrag.instanzName }); + kopf.append(instanzBadge); + } if (eintrag.source) { const quelleBadge = erstelleElement("span", { klasse: "quelle-tag", text: eintrag.source }); kopf.append(quelleBadge); diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/info.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/info.js index 7824d21..03a09f4 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/info.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/info.js @@ -2,7 +2,7 @@ // // Zeigt Anwendungsversion, Instanzkennung, Teilsysteme und OpenRouter-Guthaben an. -import { api } from "../modules/api.js"; +import { api, holeAktiveInstanz } from "../modules/api.js"; import { erstelleElement, erstelleKarte, @@ -21,6 +21,18 @@ export async function rendereInfo() { layout.append(gitter); container.append(layout); + if (!holeAktiveInstanz()) { + gitter.append( + erstelleKarte("Keine Instanz ausgewählt", [ + erstelleElement("p", { + klasse: "hinweis", + text: "Wähle oben im Kopfbereich eine aktive Instanz aus oder wechsle in den Bereich 'Instanzen', um eine Instanz zu starten." + }) + ]) + ); + return; + } + gitter.append( erstelleElement("div", { klasse: "hinweis-zentriert", text: "Lade Systemdaten…" }) ); diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/instances.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/instances.js new file mode 100644 index 0000000..503454b --- /dev/null +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/instances.js @@ -0,0 +1,433 @@ +// ClawdDotNet — Instanzverwaltung +// +// Leitfaden: Übersicht, Anlegen, Starten, Anhalten, Desktop-Fenster nach vorn holen, +// Auswahl der aktiven Instanz für das WebUI. Kein innerHTML, strikt textContent. + +import { api, holeAktiveInstanz, setzeAktiveInstanz } from "../modules/api.js"; +import { + erstelleElement, + erstelleIcon, + PFADE, + erstellePlakette, + erstelleKarte, + erstelleModal, + instanzZustandInfo, + zeigeMeldung +} from "../modules/dom.js"; + +let aktualisierungsIntervall = null; + +export async function rendereInstanzen() { + const container = document.getElementById("ansicht-inhalt"); + if (!container) return; + container.replaceChildren(); + + stoppePolling(); + + const layout = erstelleElement("div", { klasse: "instanzen-ansicht" }); + + const kopfZeile = erstelleElement("div", { klasse: "ansicht-kopf" }); + const titelGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + titelGruppe.append(erstelleElement("h1", { text: "Instanzverwaltung" })); + + const aktionenGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + + const aktualisierenBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche flach", + title: "Instanzliste manuell aktualisieren", + onclick: () => ladeInstanzen() + }, + erstelleIcon(PFADE.aktualisieren, 16), + erstelleElement("span", { text: " Aktualisieren" }) + ); + + const neuBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche primaer", + title: "Neue Instanz anlegen", + onclick: oeffneNeueInstanzDialog + }, + erstelleIcon(PFADE.plus, 16), + erstelleElement("span", { text: " Neue Instanz" }) + ); + + aktionenGruppe.append(aktualisierenBtn, neuBtn); + kopfZeile.append(titelGruppe, aktionenGruppe); + + const raster = erstelleElement("div", { klasse: "instanzen-raster", id: "instanzen-raster" }); + + layout.append(kopfZeile, raster); + container.append(layout); + + await ladeInstanzen(); + + // Hintergrund-Polling alle 4 Sekunden, da sich Zustände ohne Klick ändern können + aktualisierungsIntervall = setInterval(() => { + ladeInstanzen(true); + }, 4000); +} + +export function stoppePolling() { + if (aktualisierungsIntervall) { + clearInterval(aktualisierungsIntervall); + aktualisierungsIntervall = null; + } +} + +async function ladeInstanzen(istHintergrund = false) { + const raster = document.getElementById("instanzen-raster"); + if (!raster) { + stoppePolling(); + return; + } + + if (!istHintergrund && raster.children.length === 0) { + raster.replaceChildren( + erstelleElement("div", { klasse: "hinweis-zentriert", text: "Lade Instanzen…" }) + ); + } + + try { + const instanzen = await api("/verwaltung/instanzen"); + if (!raster) return; + raster.replaceChildren(); + + if (!Array.isArray(instanzen) || instanzen.length === 0) { + raster.append( + erstelleKarte("Keine Instanzen gefunden", [ + erstelleElement("p", { + klasse: "gedaempft", + text: "Es sind noch keine Instanzen eingerichtet. Lege mit 'Neue Instanz' eine an." + }) + ]) + ); + return; + } + + const aktiveId = holeAktiveInstanz(); + + for (const instanz of instanzen) { + const istAktiv = instanz.id === aktiveId; + const zustandInfo = instanzZustandInfo(instanz.zustand); + const istLaufend = instanz.zustand === "Running"; + const istStumm = instanz.zustand === "Silent"; + const istAbgestuerzt = instanz.zustand === "Crashed"; + + // Instanzkarte + const karteKopfAktionen = erstelleElement("div", { klasse: "gruppe-horizontal" }); + if (istAktiv) { + karteKopfAktionen.append(erstellePlakette("Aktiv im WebUI", "erfolg")); + } + karteKopfAktionen.append(erstellePlakette(zustandInfo.text, zustandInfo.art)); + + // Details + const dl = erstelleElement("dl", { klasse: "datenliste" }); + dl.append( + erstelleElement("dt", { text: "Instanz-Kennung" }), + erstelleElement("dd", {}, erstelleElement("code", { text: instanz.id })), + erstelleElement("dt", { text: "Zustand" }), + erstelleElement("dd", { text: zustandInfo.text }), + erstelleElement("dt", { text: "Prozess (PID)" }), + erstelleElement("dd", { text: instanz.prozess ? String(instanz.prozess) : "—" }), + erstelleElement("dt", { text: "Autostart durch Manager" }), + erstelleElement("dd", { + text: instanz.autostart ? "Aktiviert" : "Aus", + klasse: instanz.autostart ? "" : "gedaempft" + }) + ); + + // Aktionsleiste + const fussAktionen = erstelleElement("div", { klasse: "instanz-aktionen" }); + + // Auswählen-Knopf + const waehlenBtn = erstelleElement( + "button", + { + klasse: istAktiv ? "schaltflaeche klein" : "schaltflaeche primaer klein", + disabled: istAktiv, + title: istAktiv ? "Diese Instanz wird aktuell im WebUI bedient" : "Diese Instanz für das WebUI auswählen", + onclick: () => { + setzeAktiveInstanz(instanz.id); + zeigeMeldung(`Instanz '${instanz.name}' im WebUI ausgewählt.`, "info"); + ladeInstanzen(); + } + }, + erstelleElement("span", { text: istAktiv ? "Ausgewählt" : "Auswählen" }) + ); + + // Starten-Knopf + const startenBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche flach klein", + disabled: istLaufend, + title: istLaufend ? "Instanz läuft bereits" : "Instanz starten", + onclick: () => starteInstanz(instanz) + }, + erstelleIcon(PFADE.abspielen, 14), + erstelleElement("span", { text: " Starten" }) + ); + + // Anhalten-Knopf + const anhaltenBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche gefahr flach klein", + disabled: !istLaufend && !istStumm, + title: (!istLaufend && !istStumm) ? "Instanz läuft nicht" : "Instanz geordnet anhalten", + onclick: () => stoppeInstanz(instanz) + }, + erstelleIcon(PFADE.stop, 14), + erstelleElement("span", { text: " Anhalten" }) + ); + + // Fenster nach vorn + const fensterBtn = erstelleElement( + "button", + { + klasse: "schaltflaeche flach klein", + disabled: !istLaufend, + title: !istLaufend ? "Instanz läuft nicht" : "Desktop-Fenster dieser Instanz in den Vordergrund holen", + onclick: () => holeFensterNachVorn(instanz) + }, + erstelleIcon(PFADE.fenster, 14), + erstelleElement("span", { text: " Fenster" }) + ); + + fussAktionen.append(waehlenBtn, startenBtn, anhaltenBtn, fensterBtn); + + const karte = erstelleKarte(instanz.name, [dl, fussAktionen], { + aktionen: karteKopfAktionen, + klasse: istAktiv ? "instanz-karte aktiv" : "instanz-karte" + }); + + raster.append(karte); + } + } catch (err) { + if (!istHintergrund) { + raster.replaceChildren( + erstelleElement("div", { klasse: "fehler-zentriert", text: `Fehler beim Laden: ${err.message}` }) + ); + } + } +} + +async function starteInstanz(instanz) { + try { + const antwort = await api(`/verwaltung/instanzen/${encodeURIComponent(instanz.id)}/start`, { + method: "POST" + }); + zeigeMeldung(antwort?.meldung || `Instanz '${instanz.name}' wird gestartet…`, "erfolg"); + // Wenn bisher keine Instanz im WebUI gewählt war, diese direkt wählen + if (!holeAktiveInstanz()) { + setzeAktiveInstanz(instanz.id); + } + await ladeInstanzen(); + } catch (err) { + if (err.lizenzFehlt) { + zeigeMeldung("Start abgelehnt: Ohne gültige Lizenz startet keine Instanz (HTTP 402).", "gefahr", 6000); + } else { + zeigeMeldung(`Start fehlgeschlagen: ${err.message}`, "gefahr"); + } + } +} + +function stoppeInstanz(instanz) { + oeffneSicherheitsStoppDialog(instanz); +} + +function oeffneSicherheitsStoppDialog(instanz) { + let verbleibend = 10; + let timerId = null; + + const inhalt = erstelleElement("div", { klasse: "formular-raster" }); + + // Sicherheits-Warnbox + const sicherheitsBox = erstelleElement("div", { klasse: "sicherheits-box" }); + const boxTitel = erstelleElement( + "h3", + {}, + erstelleIcon(PFADE.ausrufezeichen, 18), + erstelleElement("span", { text: "Achtung: Produktivinstanz beenden" }) + ); + const boxText1 = erstelleElement("p", { + text: "ClawdDotNet-Instanzen sind auf Dauerbetrieb ausgelegt. Das Beenden stoppt alle aktiven Agenten, Automationen, Web-Zugriffe und Hintergrundaufgaben dieser Instanz geordnet." + }); + const boxText2 = erstelleElement("p", { + text: "Um ein versehentliches Beenden durch unbedachtes Klicken zu verhindern, ist die Bestätigung für 10 Sekunden gesperrt." + }); + sicherheitsBox.append(boxTitel, boxText1, boxText2); + + // Instanzdetails + const dl = erstelleElement("dl", { klasse: "datenliste" }); + dl.append( + erstelleElement("dt", { text: "Instanz" }), + erstelleElement("dd", {}, erstelleElement("strong", { text: instanz.name })), + erstelleElement("dt", { text: "Kennung" }), + erstelleElement("dd", {}, erstelleElement("code", { text: instanz.id })), + erstelleElement("dt", { text: "Prozess (PID)" }), + erstelleElement("dd", { text: instanz.prozess ? String(instanz.prozess) : "—" }) + ); + + // Countdown-Anzeige + const countdownBox = erstelleElement("div", { + klasse: "sicherheits-countdown", + text: `Bestätigung gesperrt: Noch ${verbleibend} Sekunden…` + }); + + inhalt.append(sicherheitsBox, dl, countdownBox); + + // Aktionen + const abbrechenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche flach", + onclick: () => modal.schliessen(), + text: "Abbrechen (Instanz läuft weiter)" + }); + + const anhaltenBtn = erstelleElement( + "button", + { + type: "button", + klasse: "schaltflaeche gefahr", + disabled: true + }, + erstelleIcon(PFADE.stop, 14), + erstelleElement("span", { text: ` Instanz anhalten (${verbleibend}s)` }) + ); + + const modal = erstelleModal( + `Instanz anhalten — ${instanz.name}`, + inhalt, + [abbrechenBtn, anhaltenBtn], + { + onSchliessen: () => { + if (timerId) { + clearInterval(timerId); + timerId = null; + } + } + } + ); + + timerId = setInterval(() => { + verbleibend--; + if (verbleibend > 0) { + countdownBox.textContent = `Bestätigung gesperrt: Noch ${verbleibend} Sekunden…`; + const textSpan = anhaltenBtn.querySelector("span"); + if (textSpan) textSpan.textContent = ` Instanz anhalten (${verbleibend}s)`; + } else { + clearInterval(timerId); + timerId = null; + anhaltenBtn.disabled = false; + const textSpan = anhaltenBtn.querySelector("span"); + if (textSpan) textSpan.textContent = " Instanz jetzt endgültig anhalten"; + countdownBox.className = "sicherheits-countdown abgelaufen"; + countdownBox.textContent = "Sperre aufgehoben — Bestätigung jetzt möglich."; + } + }, 1000); + + anhaltenBtn.addEventListener("click", async () => { + if (verbleibend > 0) return; + anhaltenBtn.disabled = true; + const textSpan = anhaltenBtn.querySelector("span"); + if (textSpan) textSpan.textContent = " Wird angehalten…"; + + try { + const antwort = await api(`/verwaltung/instanzen/${encodeURIComponent(instanz.id)}/stop`, { + method: "POST" + }); + modal.schliessen(); + zeigeMeldung(antwort?.meldung || `Instanz '${instanz.name}' beendet.`, "info"); + await ladeInstanzen(); + } catch (err) { + zeigeMeldung(`Anhalten fehlgeschlagen: ${err.message}`, "gefahr"); + anhaltenBtn.disabled = false; + if (textSpan) textSpan.textContent = " Instanz jetzt endgültig anhalten"; + } + }); + + modal.oeffnen(); +} + +async function holeFensterNachVorn(instanz) { + try { + const antwort = await api(`/verwaltung/instanzen/${encodeURIComponent(instanz.id)}/fenster`, { + method: "POST" + }); + zeigeMeldung(antwort?.meldung || `Fenster von '${instanz.name}' nach vorn geholt.`, "info"); + } catch (err) { + zeigeMeldung(`Fensteraufruf fehlgeschlagen: ${err.message}`, "warnung"); + } +} + +function oeffneNeueInstanzDialog() { + const formular = erstelleElement("form", { + klasse: "formular-raster", + id: "neue-instanz-formular" + }); + + const nameInput = erstelleElement("input", { + type: "text", + required: true, + placeholder: "z.B. Produktion oder Agenten-Labor", + autocomplete: "off" + }); + + const hinweis = erstelleElement("p", { + klasse: "hinweis", + text: "Der Instanzmanager legt dafür ein eigenes Verzeichnis mit getrennten Protokollen und Einstellungen an." + }); + + formular.append( + erstelleElement("label", { text: "Name der neuen Instanz:" }), + nameInput, + hinweis + ); + + const abbrechenBtn = erstelleElement("button", { + type: "button", + klasse: "schaltflaeche flach", + onclick: () => modal.schliessen(), + text: "Abbrechen" + }); + + // Kein eigenes onclick und kein form-Attribut: erstelleModal verknüpft Submit-Knöpfe + // im Fuß selbst mit dem Formular. Beides zusammen löste requestSubmit() zweimal aus — + // ein Klick, zwei POST, zwei Instanzen. `disabled` hilft dagegen nicht, denn + // form.requestSubmit() schert sich nicht um den Zustand eines Knopfes. + const erstellenBtn = erstelleElement("button", { + type: "submit", + klasse: "schaltflaeche primaer", + text: "Instanz anlegen" + }); + + const modal = erstelleModal("Neue Instanz anlegen", formular, [abbrechenBtn, erstellenBtn]); + + formular.addEventListener("submit", async (e) => { + e.preventDefault(); + const name = nameInput.value.trim(); + if (!name) return; + + erstellenBtn.disabled = true; + + try { + const antwort = await api("/verwaltung/instanzen", { + method: "POST", + body: { name } + }); + modal.schliessen(); + zeigeMeldung(antwort?.meldung || `Instanz '${name}' erfolgreich angelegt.`, "erfolg"); + await ladeInstanzen(); + } catch (err) { + zeigeMeldung(`Fehler beim Anlegen: ${err.message}`, "gefahr"); + } finally { + erstellenBtn.disabled = false; + } + }); + + modal.oeffnen(); +} diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/login.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/login.js index c2ce552..156b692 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/login.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/login.js @@ -29,10 +29,10 @@ export function initialisiereLogin(onErfolg) { setzeToken(token); try { - // Teste das Token gegen /api/info - const info = await api("/info"); + // Teste das Token gegen /api/verwaltung/instanzen (gehört dem Manager direkt und scheitert nie an Instanzanzahl) + const instanzen = await api("/verwaltung/instanzen"); versteckeAnmeldung(); - if (loginCallback) loginCallback(info); + if (loginCallback) loginCallback(instanzen); } catch (err) { loescheToken(); if (fehlerBox) { diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js index 14a6d6b..28d7a04 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js @@ -12,6 +12,7 @@ import { } from "../modules/dom.js"; let logStream = null; +let instanzFilter = ""; let modulFilter = ""; let levelFilter = "All"; let autoScroll = true; @@ -38,6 +39,16 @@ export async function rendereProtokoll() { const steuerungGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" }); + // Instanz-Auswahl + const instanzSelect = erstelleElement("select", { + klasse: "eingabe-select", + title: "Nach Instanz filtern", + onchange: (e) => { + instanzFilter = e.target.value; + } + }); + instanzSelect.append(erstelleElement("option", { value: "", text: "Alle Instanzen" })); + // Modul-Auswahl const modulSelect = erstelleElement("select", { klasse: "eingabe-select", @@ -102,13 +113,25 @@ export async function rendereProtokoll() { erstelleElement("span", { text: " Leeren" }) ); - steuerungGruppe.append(modulSelect, levelSelect, autoScrollLabel, pauseButton, leerenBtn); + steuerungGruppe.append(instanzSelect, modulSelect, levelSelect, autoScrollLabel, pauseButton, leerenBtn); kopfZeile.append(titelGruppe, steuerungGruppe); logContainer = erstelleElement("div", { klasse: "protokoll-strom code-block" }); layout.append(kopfZeile, logContainer); container.append(layout); + // Lade verfügbare Instanzen für Filter + try { + const instanzen = await api("/verwaltung/instanzen"); + if (Array.isArray(instanzen)) { + for (const inst of instanzen) { + instanzSelect.append(erstelleElement("option", { value: inst.id, text: inst.name })); + } + } + } catch { + // Nicht kritisch + } + // Lade verfügbare Module try { const module = await api("/logs/modules"); @@ -159,8 +182,22 @@ function starteLogStream() { function fuegeLogZeileEin(eintrag) { if (!logContainer) return; + // Filter nach Instanz falls gewählt + if (instanzFilter && eintrag.instanz && eintrag.instanz !== instanzFilter && eintrag.instanzName !== instanzFilter) { + return; + } + const zeile = erstelleElement("div", { klasse: "log-zeile" }); + if (eintrag.instanzName || eintrag.instanz) { + zeile.append( + erstelleElement("span", { + klasse: "log-instanz", + text: `[${eintrag.instanzName || eintrag.instanz}]` + }) + ); + } + if (eintrag.level) { const lvl = String(eintrag.level).toLowerCase(); const badgeArt = diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/placeholders.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/placeholders.js index 0689253..fb5a05c 100644 --- a/src/ClawdDotNet.Manager.Web/wwwroot/views/placeholders.js +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/placeholders.js @@ -27,28 +27,6 @@ export function rendereSicherung() { container.append(layout); } -export function rendereEinstellungen() { - const container = document.getElementById("ansicht-inhalt"); - if (!container) return; - container.replaceChildren(); - - const layout = erstelleElement("div", { klasse: "platzhalter-ansicht" }); - layout.append(erstelleElement("h1", { text: "Instanz-Einstellungen" })); - - const karte = erstelleKarte("In Vorbereitung", [ - erstelleElement("p", { - klasse: "gedaempft", - text: "Die Konfiguration der Instanz (Port, Token, Logging, Budget) erfolgt über die Datei 'InstanceSettings.json' bzw. über den Einstellungsdialog im Desktop-Fenster." - }), - erstelleElement("p", { - klasse: "hinweis", - text: "Ein dedizierter Web-Endpunkt zum Schreiben sensibler Zugangsdaten ist für einen späteren Meilenstein vorgesehen." - }) - ]); - - layout.append(karte); - container.append(layout); -} export function rendereAgentenChats() { const container = document.getElementById("ansicht-inhalt"); diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/settings.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/settings.js new file mode 100644 index 0000000..559f5c1 --- /dev/null +++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/settings.js @@ -0,0 +1,245 @@ +// ClawdDotNet — Einstellungen & Systemarchitektur +// +// Strikte Trennung zwischen globaler Manager-Ebene (Installation) und isolierter Instanz-Ebene. + +import { api, holeAktiveInstanz } from "../modules/api.js"; +import { + erstelleElement, + erstelleKarte, + erstellePlakette, + instanzZustandInfo, + erstelleIcon, + PFADE +} from "../modules/dom.js"; + +export async function rendereEinstellungen() { + const container = document.getElementById("ansicht-inhalt"); + if (!container) return; + container.replaceChildren(); + + const layout = erstelleElement("div", { klasse: "einstellungen-ansicht" }); + + // Kopfbereich + const kopf = erstelleElement("div", { klasse: "ansicht-kopf" }); + const kopfText = erstelleElement("div"); + kopfText.append( + erstelleElement("h1", { text: "Einstellungen & Systemarchitektur" }), + erstelleElement("p", { + klasse: "hinweis", + text: "Übersicht der Konfiguration nach dem Instanzmanager-Konzept: Strikte Trennung zwischen globaler Manager-Ebene (Installation) und isolierter Instanz-Ebene." + }) + ); + kopf.append(kopfText); + layout.append(kopf); + + // ═══════════════════════════════════════════════════════════════ + // SEKTION 1: Instanzmanager (Globale Ebene / Installation) + // ═══════════════════════════════════════════════════════════════ + + const managerSektion = erstelleElement("section", { klasse: "einstellungen-sektion sektion-manager" }); + + const managerKopf = erstelleElement("div", { klasse: "sektion-titel-zeile" }); + const managerTitelLinks = erstelleElement("div", { klasse: "gruppe-horizontal" }); + managerTitelLinks.append( + erstelleIcon(PFADE.server, 20), + erstelleElement("h2", { text: "Instanzmanager" }), + erstellePlakette("Manager-Ebene · Global", "warnung") + ); + managerKopf.append(managerTitelLinks); + + const managerIntro = erstelleElement("p", { + klasse: "gedaempft text-klein", + text: "Gilt für alle Instanzen und die Weboberfläche. Gespeichert in manager.json im Anwendungs-Hauptverzeichnis." + }); + + const managerGitter = erstelleElement("div", { klasse: "info-gitter" }); + + // Karte 1: Weboberfläche & Netzwerk + const dlNetz = erstelleElement("dl", { klasse: "datenliste" }); + dlNetz.append( + erstelleElement("dt", { text: "Konfigurationsdatei" }), + erstelleElement("dd", {}, erstelleElement("code", { text: "manager.json" })), + erstelleElement("dt", { text: "WebUI-Port" }), + erstelleElement("dd", { text: "7000 (Vorgabe, webUiPort)" }), + erstelleElement("dt", { text: "Netzwerk-Bindung" }), + erstelleElement("dd", { text: "loopback (127.0.0.1, webUiBinding)" }), + erstelleElement("dt", { text: "Zugangsschutz" }), + erstelleElement("dd", {}, erstellePlakette("Token aktiv (≥ 20 Zeichen)", "erfolg")) + ); + managerGitter.append(erstelleKarte("Weboberfläche & Netzwerk", [dlNetz])); + + // Karte 2: Lizenz & Programm-Updates + const dlLizenz = erstelleElement("dl", { klasse: "datenliste" }); + dlLizenz.append( + erstelleElement("dt", { text: "Lizenz-Geltung" }), + erstelleElement("dd", { text: "Installationsebene (E-M3: Beliebig viele Instanzen)" }), + erstelleElement("dt", { text: "Lizenzschlüssel" }), + erstelleElement("dd", {}, erstelleElement("code", { text: "●●●●-●●●●-●●●●-●●●● (verschlüsselt)" })), + erstelleElement("dt", { text: "Update-Kanal" }), + erstelleElement("dd", { text: "prod (Offizielle Release-Versionen)" }), + erstelleElement("dt", { text: "Update-Prüfung" }), + erstelleElement("dd", { text: "Zentral auf Manager-Ebene" }) + ); + managerGitter.append(erstelleKarte("Lizenz & Updates", [dlLizenz])); + + // Karte 3: Deploymentcenter & Aufsicht + const dlAufsicht = erstelleElement("dl", { klasse: "datenliste" }); + dlAufsicht.append( + erstelleElement("dt", { text: "Deploymentcenter" }), + erstelleElement("dd", { text: "https://dc.mhdf.de" }), + erstelleElement("dt", { text: "Master-Token" }), + erstelleElement("dd", {}, erstelleElement("code", { text: "●●●●●●●● (erzeugt Sub-Token je Instanz)" })), + erstelleElement("dt", { text: "Desktop-Fenster" }), + erstelleElement("dd", { text: "Aktiv (jede Instanz hat ein eigenes Fenster)" }), + erstelleElement("dt", { text: "Absturz-Schutz" }), + erstelleElement("dd", { text: "Max. 5 Neustarts / 10 Minuten" }) + ); + managerGitter.append(erstelleKarte("Deploymentcenter & Aufsicht", [dlAufsicht])); + + managerSektion.append(managerKopf, managerIntro, managerGitter); + layout.append(managerSektion); + + // ═══════════════════════════════════════════════════════════════ + // SEKTION 2: Aktive Instanz (Instanz-Ebene) + // ═══════════════════════════════════════════════════════════════ + + const instanzSektion = erstelleElement("section", { klasse: "einstellungen-sektion sektion-instanz" }); + + const aktiveId = holeAktiveInstanz(); + let instanzenListe = []; + try { + instanzenListe = await api("/verwaltung/instanzen"); + } catch { + // Wenn Liste nicht abrufbar, weiter + } + + const aktiveInstanz = instanzenListe.find((i) => i.id === aktiveId); + const zInfo = aktiveInstanz ? instanzZustandInfo(aktiveInstanz.zustand) : { text: "Keine gewählt", art: "neutral" }; + + const instanzKopf = erstelleElement("div", { klasse: "sektion-titel-zeile" }); + const instanzTitelLinks = erstelleElement("div", { klasse: "gruppe-horizontal" }); + instanzTitelLinks.append( + erstelleIcon(PFADE.fenster, 20), + erstelleElement("h2", { text: aktiveInstanz ? `Aktive Instanz: ${aktiveInstanz.name}` : "Instanzbezogene Einstellungen" }), + erstellePlakette("Instanz-Ebene · Isoliert", "erfolg"), + aktiveInstanz ? erstellePlakette(zInfo.text, zInfo.art) : erstellePlakette("Keine Instanz aktiv", "neutral") + ); + instanzKopf.append(instanzTitelLinks); + + const instanzIntro = erstelleElement("p", { + klasse: "gedaempft text-klein", + text: "Gilt ausschließlich für die aktuell ausgewählte Instanz. Alle Pfade, Protokolle, Agenten und Budgets sind strikt von anderen Instanzen isoliert." + }); + + instanzSektion.append(instanzKopf, instanzIntro); + + if (!aktiveInstanz) { + const leerKarte = erstelleKarte("Keine Instanz ausgewählt", [ + erstelleElement("p", { + klasse: "hinweis", + text: "Bitte wähle oben im Kopfbereich eine aktive Instanz aus oder wechsle in den Bereich 'Instanzen', um eine Instanz zu starten oder auszuwählen." + }), + erstelleElement("a", { + href: "#/instanzen", + klasse: "schaltflaeche primaer klein", + text: "Zur Instanzen-Übersicht" + }) + ]); + instanzSektion.append(leerKarte); + } else { + // Daten von der laufenden Instanz abfragen (sofern sie läuft) + const [instanzInfo, instanzStatus] = await Promise.all([ + api("/info").catch(() => null), + api("/status").catch(() => null) + ]); + + const instanzGitter = erstelleElement("div", { klasse: "info-gitter" }); + + // Karte 1: Instanz-Identität & Autostart + const dlIdent = erstelleElement("dl", { klasse: "datenliste" }); + dlIdent.append( + erstelleElement("dt", { text: "Instanzname" }), + erstelleElement("dd", {}, erstelleElement("strong", { text: aktiveInstanz.name })), + erstelleElement("dt", { text: "Instanz-ID" }), + erstelleElement("dd", {}, erstelleElement("code", { text: aktiveInstanz.id })), + erstelleElement("dt", { text: "Konfigurationsdatei" }), + erstelleElement("dd", {}, erstelleElement("code", { text: `Instances/${aktiveInstanz.name}/InstanceSettings.json` })), + erstelleElement("dt", { text: "Autostart durch Manager" }), + erstelleElement("dd", {}, erstellePlakette(aktiveInstanz.autostart ? "Aktiv (Am Laufen halten)" : "Inaktiv (Manueller Start)", aktiveInstanz.autostart ? "erfolg" : "neutral")), + erstelleElement("dt", { text: "Kommunikation" }), + erstelleElement("dd", { text: "HTTP über Named Pipe (Windows) / Socket (Linux)" }) + ); + instanzGitter.append(erstelleKarte("Identität & Prozess", [dlIdent])); + + // Karte 2: Isolierte Verzeichnisse & Speicher + const dlPfade = erstelleElement("dl", { klasse: "datenliste" }); + dlPfade.append( + erstelleElement("dt", { text: "Protokolle (Logs)" }), + erstelleElement("dd", {}, erstelleElement("code", { text: `Instances/${aktiveInstanz.name}/Logs/` })), + erstelleElement("dt", { text: "Datensicherungen" }), + erstelleElement("dd", {}, erstelleElement("code", { text: `Instances/${aktiveInstanz.name}/Backups/` })), + erstelleElement("dt", { text: "Zustandsdatenbank" }), + erstelleElement("dd", {}, erstelleElement("code", { text: `Instances/${aktiveInstanz.name}/state.db (exklusiv)` })), + erstelleElement("dt", { text: "Arbeitsbereich (Shared)" }), + erstelleElement("dd", {}, erstelleElement("code", { text: `Instances/${aktiveInstanz.name}/Agents/SharedWorkspace/` })) + ); + instanzGitter.append(erstelleKarte("Isolierte Verzeichnisse", [dlPfade])); + + // Karte 3: Modellanbindung & Budget (OpenRouter) + const dlModell = erstelleElement("dl", { klasse: "datenliste" }); + if (instanzStatus) { + dlModell.append( + erstelleElement("dt", { text: "OpenRouter-Status" }), + erstelleElement("dd", {}, erstellePlakette(instanzStatus.isApiReachable ? "Verbunden" : "Offline", instanzStatus.isApiReachable ? "erfolg" : "gefahr")), + erstelleElement("dt", { text: "Statusmeldung" }), + erstelleElement("dd", { text: instanzStatus.statusText || "—" }), + erstelleElement("dt", { text: "Guthaben / Credits" }), + erstelleElement("dd", {}, erstelleElement("strong", { text: instanzStatus.creditsText || "—" })), + erstelleElement("dt", { text: "API-Schlüssel" }), + erstelleElement("dd", { text: "In InstanceSettings.json dieser Instanz maskiert hinterlegt" }) + ); + } else { + dlModell.append( + erstelleElement("dt", { text: "OpenRouter" }), + erstelleElement("dd", { + klasse: "gedaempft", + text: aktiveInstanz.zustand === "Running" + ? "Kein Schlüssel hinterlegt oder Dienst nicht erreichbar." + : "Instanz läuft nicht. Daten werden nach dem Start geladen." + }) + ); + } + instanzGitter.append(erstelleKarte("Modellanbindung (OpenRouter)", [dlModell])); + + // Karte 4: Teilsysteme der Instanz + const dlSysteme = erstelleElement("dl", { klasse: "datenliste" }); + if (instanzInfo) { + dlSysteme.append( + erstelleElement("dt", { text: "Agent Engine" }), + erstelleElement("dd", {}, erstellePlakette(instanzInfo.engineActive ? "Aktiv" : "Aus", instanzInfo.engineActive ? "erfolg" : "neutral")), + erstelleElement("dt", { text: "Scanner / Scheduler" }), + erstelleElement("dd", {}, erstellePlakette(instanzInfo.schedulerActive ? "Aktiv" : "Aus", instanzInfo.schedulerActive ? "erfolg" : "neutral")), + erstelleElement("dt", { text: "Freigabestelle (Staging)" }), + erstelleElement("dd", {}, erstellePlakette(instanzInfo.stagingActive ? "Aktiv" : "Aus", instanzInfo.stagingActive ? "erfolg" : "neutral")), + erstelleElement("dt", { text: "Deploymentcenter Sub-Token" }), + erstelleElement("dd", {}, erstellePlakette(instanzInfo.deploymentcenterActive ? "Aktiv" : "Aus", instanzInfo.deploymentcenterActive ? "erfolg" : "neutral")) + ); + } else { + dlSysteme.append( + erstelleElement("dt", { text: "Subsysteme" }), + erstelleElement("dd", { + klasse: "gedaempft", + text: aktiveInstanz.zustand === "Running" + ? "Laufzeitdaten werden abgefragt…" + : "Instanz ist beendet — Teilsysteme ruhen." + }) + ); + } + instanzGitter.append(erstelleKarte("Laufzeit & Teilsysteme", [dlSysteme])); + + instanzSektion.append(instanzGitter); + } + + layout.append(instanzSektion); + container.append(layout); +} diff --git a/src/ClawdDotNet.Manager/InstanceChannel.cs b/src/ClawdDotNet.Manager/InstanceChannel.cs index 9816995..ff39826 100644 --- a/src/ClawdDotNet.Manager/InstanceChannel.cs +++ b/src/ClawdDotNet.Manager/InstanceChannel.cs @@ -3,8 +3,34 @@ using ClawdDotNet.Core.Instances; namespace ClawdDotNet.Manager; -/// Was eine Instanz über sich sagt, wenn man sie über ihren Socket fragt. -public sealed record InstanceIdentity(string InstanceId, string InstanceName, string AppVersion); +/// +/// Was eine Instanz über sich sagt, wenn man sie über ihren Socket fragt — ihr Puls. +/// +/// Die Identität ist der Beweis, der Rest ist die Auskunft. Dass überhaupt +/// jemand antwortet, unterscheidet „läuft" von „tot". Erst +/// und unterscheiden die beiden Fälle, die +/// gleich aussehen und gegensätzlich zu behandeln sind: eine Instanz, die hängt, und +/// eine, die gerade geordnet aufräumt. +/// +/// Läuft, fährt herunter, ist fertig. +/// Wie viele Arbeiten beim Herunterfahren noch auslaufen. +/// Was das im Klartext ist, fürs Protokoll. +public sealed record InstanceIdentity( + string InstanceId, + string InstanceName, + string AppVersion, + ShutdownPhase Phase = ShutdownPhase.Running, + int OpenWork = 0, + string OpenSummary = "") +{ + /// + /// Fährt diese Instanz gerade geordnet herunter und ist dabei noch beschäftigt? + /// + /// Die Aufsicht darf so eine Instanz nicht abschießen — sie tut genau das, + /// worum gebeten wurde. + /// + public bool IsWindingDown => Phase == ShutdownPhase.Draining; +} /// /// Das Gespräch mit einer Instanz über ihren Socket: Wer bist du — und bitte beende dich. @@ -74,18 +100,26 @@ public sealed class SocketInstanceChannel(TimeSpan? timeout = null) : IInstanceC using var client = InstanceEndpoint.CreateClient(instanceDirectory); client.Timeout = _timeout; - using var antwort = await client.GetAsync("/api/info", ct).ConfigureAwait(false); + // Der Puls und nicht /api/info: Er liegt hinter dem Socket-Gate, gehoert also + // dem Manager allein, und er sagt zusaetzlich, ob die Instanz gerade + // aufraeumt. Von dieser Unterscheidung haengt ab, ob abgeschossen wird. + using var antwort = await client + .GetAsync("/api/instanz/puls", ct).ConfigureAwait(false); if (!antwort.IsSuccessStatusCode) return null; var json = await antwort.Content.ReadAsStringAsync(ct).ConfigureAwait(false); using var doc = JsonDocument.Parse(json); + var root = doc.RootElement; return new InstanceIdentity( - Text(doc.RootElement, "instanceId"), - Text(doc.RootElement, "instanceName"), - Text(doc.RootElement, "appVersion")); + Text(root, "instanceId"), + Text(root, "instanceName"), + Text(root, "appVersion"), + Phase(root), + Zahl(root, "offenGesamt"), + Beschreibung(root)); } catch (OperationCanceledException) when (ct.IsCancellationRequested) { @@ -139,4 +173,31 @@ public sealed class SocketInstanceChannel(TimeSpan? timeout = null) : IInstanceC => root.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() ?? "" : ""; + + private static int Zahl(JsonElement root, string name) + => root.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.Number + ? v.GetInt32() + : 0; + + /// + /// Die Phase aus der Antwort — im Zweifel Running. + /// + /// Ein unbekannter Wert darf hier nicht als „fährt herunter" durchgehen: Das + /// wäre der Freibrief, mit dem eine hängende Instanz beliebig lange stehen bliebe. + /// Running ist die Auslegung, bei der die Aufsicht wachsam bleibt. + /// + private static ShutdownPhase Phase(JsonElement root) + => Enum.TryParse(Text(root, "phase"), ignoreCase: true, out var phase) + ? phase + : ShutdownPhase.Running; + + private static string Beschreibung(JsonElement root) + { + if (!root.TryGetProperty("offeneArbeiten", out var liste) + || liste.ValueKind != JsonValueKind.Array) + return ""; + + return string.Join(", ", liste.EnumerateArray() + .Select(e => $"{Text(e, "name")}: {Zahl(e, "anzahl")}")); + } } diff --git a/src/ClawdDotNet.Manager/InstanceRegistry.cs b/src/ClawdDotNet.Manager/InstanceRegistry.cs index bfadf7b..2efef61 100644 --- a/src/ClawdDotNet.Manager/InstanceRegistry.cs +++ b/src/ClawdDotNet.Manager/InstanceRegistry.cs @@ -249,6 +249,15 @@ public sealed class InstanceRegistry : IAsyncDisposable } } + /// + /// Die Aufsicht über eine bestimmte Instanz, oder null. + /// + /// Damit sich ein Aufsichtsdurchgang von außen auslösen lässt, statt auf die Uhr + /// zu warten — Tests mit Wartezeiten sind Tests, die man irgendwann abschaltet. + /// + public InstanceSupervisor? SupervisorFor(string instanceDirectory) + => _supervisors.GetValueOrDefault(Path.GetFullPath(instanceDirectory)); + private InstanceSupervisor Find(string instanceDirectory) { var pfad = Path.GetFullPath(instanceDirectory); diff --git a/src/ClawdDotNet.Manager/InstanceSupervisor.cs b/src/ClawdDotNet.Manager/InstanceSupervisor.cs index 9d00862..e0521d0 100644 --- a/src/ClawdDotNet.Manager/InstanceSupervisor.cs +++ b/src/ClawdDotNet.Manager/InstanceSupervisor.cs @@ -34,17 +34,37 @@ public enum InstanceCondition /// die Aufsicht ihr Geld nicht mehr wert. /// /// Wie lange eine Instanz nach der Bitte zu enden noch bekommt. +/// +/// Wie lange eine verstummte Instanz nach der angeordneten Beendigung noch bekommt. +/// +/// Der Bitte über den Socket ist bei einer Instanz, die eben auf demselben Socket +/// nicht geantwortet hat, wenig zuzutrauen — sie kostet einen Versuch und wird deshalb +/// unternommen, aber gewartet wird nicht auf sie, sondern auf die Uhr. Antwortet die +/// Instanz in dieser Zeit wieder, war es ein Aussetzer und niemand wird abgeschossen. +/// +/// +/// Die absolute Obergrenze beim Anhalten, wenn die Instanz meldet, dass sie aufräumt. +/// +/// Muss größer sein als die Frist, die sich die Instanz selbst gibt +/// (ShutdownCoordinator.Budget) — sonst schießt der Manager mitten in das +/// Aufräumen hinein, um das er gerade gebeten hat. Und trotzdem endlich: Eine Instanz, +/// die dauerhaft „ich räume noch auf" sagt, hängt genauso wie eine, die schweigt. +/// public sealed record SupervisionOptions( TimeSpan ProbeInterval, TimeSpan StartTimeout, int SilentChecksBeforeAlarm, - TimeSpan StopGrace) + TimeSpan StopGrace, + TimeSpan SilentKillGrace, + TimeSpan MaxDrainWait) { public static SupervisionOptions Default { get; } = new( ProbeInterval: TimeSpan.FromSeconds(15), StartTimeout: TimeSpan.FromSeconds(60), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromSeconds(20)); + StopGrace: TimeSpan.FromSeconds(20), + SilentKillGrace: TimeSpan.FromSeconds(30), + MaxDrainWait: TimeSpan.FromMinutes(5)); } /// @@ -91,6 +111,9 @@ public sealed class InstanceSupervisor : IAsyncDisposable private int _silentChecks; private bool _stopRequested; + /// Seit wann das Verstummen andauert — der Beginn der Frist bis zum harten Ende. + private DateTimeOffset? _silentSince; + public InstanceSupervisor( string instanceDirectory, IInstanceLauncher launcher, @@ -136,23 +159,58 @@ public sealed class InstanceSupervisor : IAsyncDisposable /// public async Task StartAsync(CancellationToken ct = default) { - if (Condition == InstanceCondition.Running) - { - // Nicht dem eigenen Merkzettel glauben, sondern nachfragen. Zwischen zwei - // Aufsichtsdurchgaengen liegen Sekunden, und in denen kann die Instanz weg - // sein: Wer hier "laeuft schon" antwortet, meldet einen Erfolg, hinter dem - // nichts steht - und der naechste Durchgang meldet dann den Absturz, den - // niemand mehr erwartet. - if (await _channel.AskAsync(InstanceDirectory, ct).ConfigureAwait(false) is not null) - return true; + // Nicht dem eigenen Merkzettel glauben, sondern nachfragen - und zwar immer, + // nicht nur wenn die Aufsicht die Instanz fuer laufend haelt. Zwischen zwei + // Durchgaengen liegen Sekunden, und in denen kann sie ebenso wegbrechen wie + // wiederkommen. Wer hier ungefragt startet, setzt im zweiten Fall einen zweiten + // Prozess auf dieselbe state.db. + var vorhanden = await _channel.AskAsync(InstanceDirectory, ct).ConfigureAwait(false); - _logger.LogInformation( - "Instanz {Name} galt als laufend, antwortet aber nicht mehr — sie wird gestartet.", - InstanceName); + if (vorhanden is not null) + { + if (vorhanden.IsWindingDown) + { + // Sie faehrt gerade herunter. Jetzt zu starten hiesse, den neuen Prozess + // gegen den alten laufen zu lassen, waehrend der noch aufraeumt. + _logger.LogWarning( + "Instanz {Name} fährt gerade herunter ({Offen} offen) — es wird nicht " + + "gestartet, solange sie das tut.", + InstanceName, vorhanden.OpenSummary); + + return false; + } + + if (Condition != InstanceCondition.Running) + { + _logger.LogInformation( + "Instanz {Name} galt als {Zustand}, antwortet aber — sie wird übernommen " + + "statt gestartet.", InstanceName, Condition); + } + + InstanceName = vorhanden.InstanceName; + Condition = InstanceCondition.Running; + _silentChecks = 0; + _silentSince = null; + + return true; + } + + // Ab hier antwortet niemand. Bevor gestartet wird, muss ein etwaiger alter + // Prozess nachweislich weg sein - genau hier entsteht sonst der Schaden, gegen + // den dieses ganze Vorhaben gebaut ist: zwei Prozesse auf einer Datenbank. + if (!await EnsureDeadAsync(ct).ConfigureAwait(false)) + { + Raise(InstanceEventKind.StartFailed, _process?.Id, null, + $"Instanz {InstanceName} wird nicht gestartet: Der bisherige Prozess " + + $"{_process?.Id} lebt noch und war nicht zu beenden. Zwei Prozesse auf " + + "derselben Datenbank wären schlimmer als eine Instanz, die aus bleibt."); + + return false; } _stopRequested = false; _silentChecks = 0; + _silentSince = null; try { @@ -207,6 +265,57 @@ public sealed class InstanceSupervisor : IAsyncDisposable return true; } + /// + /// Stellt sicher, dass der bisherige Prozess wirklich weg ist — notfalls mit Gewalt. + /// + /// Warum das eine eigene Prüfung ist. Kill() ist eine Bitte an das + /// Betriebssystem, keine vollzogene Tatsache: Der Aufruf kehrt zurück, bevor der + /// Prozess verschwunden ist, und bis dahin hält er die Datenbank und den Socket. Wer + /// unmittelbar danach startet, hat für einen Moment zwei Prozesse auf einer + /// state.db — und das ist kein Moment, sondern eine kaputte Datei. + /// + /// Ohne Prozesshandle gilt der Socket. Bei einer wiederaufgenommenen + /// Instanz gibt es nichts zu greifen (siehe ). Dann ist + /// die einzige verfügbare Auskunft, dass niemand mehr antwortet — und die muss + /// reichen, denn mehr ist nicht zu haben. + /// + /// true, wenn nachweislich nichts mehr läuft. + public async Task EnsureDeadAsync(CancellationToken ct = default) + { + if (_process is null) + { + // Kein Handle: Der Socket ist der einzige Zeuge. Wer hier gerufen wird, hat + // ihn gerade gefragt - aber ein zweites Mal fragen kostet nichts und deckt + // den Fall ab, dass zwischendurch jemand hochgekommen ist. + return await _channel.AskAsync(InstanceDirectory, ct).ConfigureAwait(false) is null; + } + + if (_process.HasExited) + return true; + + _logger.LogWarning( + "Prozess {Pid} von Instanz {Name} lebt noch — er wird beendet, bevor " + + "irgendetwas Neues startet.", _process.Id, InstanceName); + + try { _process.Kill(); } + catch (Exception ex) + { + _logger.LogError(ex, "Prozess {Pid} liess sich nicht beenden.", _process.Id); + } + + // Kill ist eine Bitte. Auf den Vollzug wird gewartet. + var deadline = _clock.GetUtcNow() + _options.SilentKillGrace; + + while (_clock.GetUtcNow() < deadline) + { + if (_process.HasExited) return true; + + await Task.Delay(TimeSpan.FromMilliseconds(250), _clock, ct).ConfigureAwait(false); + } + + return _process.HasExited; + } + private async Task WaitForAnswerAsync(CancellationToken ct) { var deadline = _clock.GetUtcNow() + _options.StartTimeout; @@ -324,6 +433,7 @@ public sealed class InstanceSupervisor : IAsyncDisposable if (identity is not null) { _silentChecks = 0; + _silentSince = null; if (Condition == InstanceCondition.Silent) { @@ -336,6 +446,17 @@ public sealed class InstanceSupervisor : IAsyncDisposable Condition = InstanceCondition.Running; } + if (identity.IsWindingDown) + { + // Kein Vorkommnis, sondern eine Auskunft: Sie tut, worum gebeten wurde. + // Ins Protokoll gehoert es trotzdem - hinterher will jemand nachlesen + // koennen, wie lange das Aufraeumen gedauert hat und woran. + _logger.LogInformation( + "Instanz {Name} fährt herunter, noch offen: {Offen}.", + InstanceName, string.IsNullOrEmpty(identity.OpenSummary) + ? "nichts" : identity.OpenSummary); + } + return; } @@ -364,16 +485,101 @@ public sealed class InstanceSupervisor : IAsyncDisposable _silentChecks++; if (Condition == InstanceCondition.Silent) - return; // Schon gemeldet. Ein Alarm je Vorfall, nicht je Durchgang. + { + // Der Vorfall laeuft schon. Kein zweiter Alarm - aber die Uhr laeuft. + await EskalierenAsync(ct).ConfigureAwait(false); + return; + } if (_silentChecks < _options.SilentChecksBeforeAlarm) return; Condition = InstanceCondition.Silent; + _silentSince = _clock.GetUtcNow(); Raise(InstanceEventKind.Unresponsive, _process?.Id, null, $"Instanz {InstanceName} läuft, antwortet aber seit {_silentChecks} Durchgängen " - + $"nicht mehr auf {InstanceEndpoint.Describe(InstanceDirectory)}."); + + $"nicht mehr auf {InstanceEndpoint.Describe(InstanceDirectory)}. Sie wird " + + $"gebeten zu enden; nach {_options.SilentKillGrace.TotalSeconds:0}s ohne " + + "Antwort wird der Prozess beendet."); + + // Ein Versuch, mehr nicht. Wer eben auf demselben Socket nicht geantwortet hat, + // wird die Bitte wahrscheinlich auch nicht hoeren - aber "wahrscheinlich nicht" + // ist kein Grund, es zu lassen: Es kann ein einzelner haengender Endpunkt sein + // und nicht der ganze Prozess. Gewartet wird auf die Uhr, nicht auf die Antwort. + try + { + if (await _channel.RequestStopAsync(InstanceDirectory, ct).ConfigureAwait(false)) + { + // Ausdruecklich ohne _stopRequested: Niemand hat gewollt, dass diese + // Instanz endet. Sie antwortet nicht, und was daraufhin passiert, ist ein + // Absturz und keine geordnete Beendigung - auch dann, wenn der letzte + // Anstoss von hier kam. Nur so greift der Autostart, und nur so steht + // hinterher im Protokoll, was wirklich vorgefallen ist. + _logger.LogInformation( + "Die Bitte zu enden ist bei der verstummten Instanz {Name} angekommen.", + InstanceName); + } + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + _logger.LogInformation(ex, + "Die Bitte zu enden erreichte die verstummte Instanz {Name} nicht.", InstanceName); + } + } + + /// + /// Die Frist für eine verstummte Instanz läuft ab: Der Prozess wird beendet. + /// + /// Erst hier, nicht beim ersten Schweigen. Zwischen „antwortet gerade nicht" und + /// „ist hin" liegt ein Agentenlauf, der die Maschine auslastet — und ein Manager, der + /// dabei abschießt, ist schlimmer als gar keiner. + /// + private async Task EskalierenAsync(CancellationToken ct) + { + if (_silentSince is not { } seit) return; + + var verstrichen = _clock.GetUtcNow() - seit; + if (verstrichen < _options.SilentKillGrace) return; + + if (_process is null) + { + // Nicht zu greifen (siehe ReattachAsync). Einmal melden, dann Ruhe - sonst + // steht diese Zeile in jedem Durchgang bis in alle Ewigkeit. + _silentSince = null; + + _logger.LogError( + "Instanz {Name} antwortet seit {Dauer:0}s nicht und ist von diesem Manager " + + "nicht zu beenden — es gibt keinen Prozess, den er greifen kann.", + InstanceName, verstrichen.TotalSeconds); + + return; + } + + _logger.LogWarning( + "Instanz {Name} antwortet seit {Dauer:0}s nicht — der Prozess wird beendet.", + InstanceName, verstrichen.TotalSeconds); + + var pid = _process.Id; + var tot = await EnsureDeadAsync(ct).ConfigureAwait(false); + + _silentSince = null; + + if (!tot) + { + _logger.LogError( + "Prozess {Pid} von Instanz {Name} liess sich nicht beenden. Sie bleibt " + + "unter Aufsicht; gestartet wird nichts, solange er lebt.", pid, InstanceName); + + return; + } + + Condition = InstanceCondition.Crashed; + InstanceStateStore.Clear(InstanceDirectory); + + Raise(InstanceEventKind.Crashed, pid, _process.ExitCode, + $"Instanz {InstanceName} hat {verstrichen.TotalSeconds:0}s nicht geantwortet " + + "und wurde beendet."); } /// Sieht von selbst nach, im eingestellten Takt. @@ -424,17 +630,53 @@ public sealed class InstanceSupervisor : IAsyncDisposable + "es gilt trotzdem die Frist.", InstanceName); } - var deadline = _clock.GetUtcNow() + _options.StopGrace; + var begonnen = _clock.GetUtcNow(); + var hartesEnde = begonnen + _options.MaxDrainWait; + var deadline = begonnen + _options.StopGrace; + var aufraeumenGemeldet = false; while (_clock.GetUtcNow() < deadline) { - if (_process is { HasExited: true } - || await _channel.AskAsync(InstanceDirectory, ct).ConfigureAwait(false) is null) + if (_process is { HasExited: true }) { - Finish(_process?.ExitCode, gewaltsam: false); + Finish(_process.ExitCode, gewaltsam: false); return true; } + var puls = await _channel.AskAsync(InstanceDirectory, ct).ConfigureAwait(false); + + if (puls is null) + { + // Schweigen ist nur dann ein Beweis, wenn es keinen anderen Zeugen gibt. + // Haelt dieser Manager ein Prozesshandle und sagt es "lebt noch", dann + // lebt der Prozess - er antwortet bloss nicht mehr. Wer hier "beendet" + // meldet und anschliessend neu startet, setzt einen zweiten Prozess auf + // dieselbe state.db. Genau das war der Anlass dieses Vorhabens. + if (_process is null) + { + Finish(null, gewaltsam: false); + return true; + } + } + else if (puls.IsWindingDown) + { + // Sie raeumt auf - also tut sie genau das, worum gebeten wurde. Solange + // das laeuft, wird die Frist nachgezogen, aber nicht ins Unendliche: + // MaxDrainWait ist die Grenze, hinter der auch "ich raeume noch auf" + // nur noch eine andere Art zu haengen ist. + var neu = _clock.GetUtcNow() + _options.StopGrace; + deadline = neu < hartesEnde ? neu : hartesEnde; + + if (!aufraeumenGemeldet) + { + aufraeumenGemeldet = true; + + _logger.LogInformation( + "Instanz {Name} räumt auf ({Offen}) — es wird bis zu {Grenze:0}s gewartet.", + InstanceName, puls.OpenSummary, _options.MaxDrainWait.TotalSeconds); + } + } + await Task.Delay(TimeSpan.FromMilliseconds(250), _clock, ct).ConfigureAwait(false); } @@ -450,10 +692,18 @@ public sealed class InstanceSupervisor : IAsyncDisposable } _logger.LogWarning( - "Instanz {Name} hat binnen {Frist}s nicht geendet — sie wird beendet.", - InstanceName, _options.StopGrace.TotalSeconds); + "Instanz {Name} hat binnen {Frist:0}s nicht geendet — sie wird beendet.", + InstanceName, (_clock.GetUtcNow() - begonnen).TotalSeconds); + + if (!await EnsureDeadAsync(ct).ConfigureAwait(false)) + { + _logger.LogError( + "Prozess {Pid} von Instanz {Name} liess sich nicht beenden.", + _process.Id, InstanceName); + + return false; + } - _process.Kill(); Finish(_process.ExitCode, gewaltsam: true); return true; } diff --git a/src/ClawdDotNet.Manager/ManagerCore.cs b/src/ClawdDotNet.Manager/ManagerCore.cs index f8d4284..5c63e48 100644 --- a/src/ClawdDotNet.Manager/ManagerCore.cs +++ b/src/ClawdDotNet.Manager/ManagerCore.cs @@ -102,6 +102,10 @@ public sealed class ManagerCore : IAsyncDisposable if (_reporter is not null) _ = _reporter.ReportAsync(ereignis); + // Nur beim Absturz, und das schliesst die verstummte Instanz ein: Die + // Aufsicht beendet sie nach ihrer Frist und meldet das als Absturz - denn + // gewollt hat es niemand. Ein zweiter Einstieg bei "Unresponsive" waere ein + // zweiter Neustart fuer denselben Vorfall. if (ereignis.Kind == InstanceEventKind.Crashed) _ = RestartAfterCrashAsync(ereignis); }; diff --git a/src/ClawdDotNet.Manager/ManagerSettings.cs b/src/ClawdDotNet.Manager/ManagerSettings.cs index b2501fd..ae5426e 100644 --- a/src/ClawdDotNet.Manager/ManagerSettings.cs +++ b/src/ClawdDotNet.Manager/ManagerSettings.cs @@ -130,6 +130,22 @@ public sealed class ManagerSettings [JsonPropertyName("restartWindowMinutes")] public int RestartWindowMinutes { get; set; } = 10; + /// + /// Wie lange eine verstummte Instanz nach der angeordneten Beendigung noch bekommt, + /// bevor der Prozess hart beendet wird. + /// + [JsonPropertyName("silentKillGraceSeconds")] + public int SilentKillGraceSeconds { get; set; } = 30; + + /// + /// Die Obergrenze beim Anhalten, solange die Instanz meldet, dass sie aufräumt. + /// + /// Muss über der Frist liegen, die sich die Instanz selbst gibt — sonst schießt + /// der Manager in das Aufräumen hinein, um das er gebeten hat. + /// + [JsonPropertyName("maxDrainWaitSeconds")] + public int MaxDrainWaitSeconds { get; set; } = 300; + /// Die geprüfte Neustartregel. public RestartPolicy ToRestartPolicy() => new( MaxRestarts: Math.Clamp(MaxRestartsInWindow, 1, 100), @@ -146,7 +162,9 @@ public sealed class ManagerSettings ProbeInterval: TimeSpan.FromSeconds(Math.Clamp(ProbeIntervalSeconds, 1, 3600)), StartTimeout: TimeSpan.FromSeconds(Math.Clamp(StartTimeoutSeconds, 5, 600)), SilentChecksBeforeAlarm: Math.Clamp(SilentChecksBeforeAlarm, 1, 100), - StopGrace: TimeSpan.FromSeconds(Math.Clamp(StopGraceSeconds, 1, 600))); + StopGrace: TimeSpan.FromSeconds(Math.Clamp(StopGraceSeconds, 1, 600)), + SilentKillGrace: TimeSpan.FromSeconds(Math.Clamp(SilentKillGraceSeconds, 1, 600)), + MaxDrainWait: TimeSpan.FromSeconds(Math.Clamp(MaxDrainWaitSeconds, 1, 3600))); } /// diff --git a/src/ClawdDotNet.ManagerApp/Program.cs b/src/ClawdDotNet.ManagerApp/Program.cs index ba31792..24947d9 100644 --- a/src/ClawdDotNet.ManagerApp/Program.cs +++ b/src/ClawdDotNet.ManagerApp/Program.cs @@ -97,7 +97,24 @@ internal static class Program return ExitNoWebUi; } - Console.WriteLine(web.Url); + Console.WriteLine(); + Console.WriteLine("================================================="); + Console.WriteLine(" ClawdDotNet Instanzmanager bereit"); + Console.WriteLine($" Weboberfläche: {web.Url}"); + if (!string.IsNullOrWhiteSpace(settings.Settings.WebUiToken)) + { + Console.WriteLine($" Token: {settings.Settings.WebUiToken}"); + } + else + { + Console.WriteLine(" Token: (kein Token erforderlich)"); + } + Console.WriteLine("================================================="); + Console.WriteLine(); + // Das Token steht auf der Konsole, aber ausdruecklich NICHT im Protokoll: Es ist + // der Generalschluessel zu allen Instanzen, und die Protokolldatei ist genau die, + // die man an einen Fehlerbericht haengt. Vor der Konsole steht, wer den Manager + // gestartet hat; die Datei liest hinterher irgendwer. logger.LogInformation("Instanzmanager bereit. Weboberfläche: {Url}", web.Url); await WaitForShutdownAsync(logger); diff --git a/src/ClawdDotNet.Web/Contracts/Dtos.cs b/src/ClawdDotNet.Web/Contracts/Dtos.cs index 56ad5de..7d661ff 100644 --- a/src/ClawdDotNet.Web/Contracts/Dtos.cs +++ b/src/ClawdDotNet.Web/Contracts/Dtos.cs @@ -175,3 +175,14 @@ public sealed record UsageDto( /// Eine Protokollzeile. public sealed record LogLineDto(string Module, string Level, string Text); + +/// Eine interne Kommunikation zwischen Agenten (A2A, #208). +public sealed record AgentCommunicationDto( + string TargetAgentId, + string TargetAgentName, + string? SourceAgentId, + string? SourceAgentName, + string Role, + string Content, + DateTime Timestamp); + diff --git a/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs b/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs index 150dc64..6114c75 100644 --- a/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs +++ b/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs @@ -101,6 +101,58 @@ internal static class ApiEndpoints .ToList(); }); + // ─── Interne Agenten-Kommunikation (A2A, #208) ─── + agents.MapGet("/communications", (AppHost host) => + { + if (host.Engine is not { } engine) + return Unavailable("Agent-Engine ist nicht aktiv (kein API-Schlüssel)."); + + var allAgents = host.AgentAdmin.All; + var list = new List(); + + foreach (var agent in allAgents) + { + var history = engine.GetChatHistory(agent.AgentId); + foreach (var entry in history.Where(e => string.Equals(e.Source, Core.Engine.ChatSource.AgentComm, StringComparison.OrdinalIgnoreCase))) + { + string? senderId = null; + string? senderName = null; + var content = entry.Content; + + if (entry.Role == "user" && content.StartsWith("[Nachricht von Agent \"")) + { + var endQuote = content.IndexOf('"', 22); + if (endQuote > 22) + { + senderName = content[22..endQuote]; + var openParen = content.IndexOf('(', endQuote); + var closeParen = content.IndexOf(')', openParen); + if (openParen > 0 && closeParen > openParen) + { + senderId = content[(openParen + 1)..closeParen]; + } + } + var doubleNl = content.IndexOf("\n\n", StringComparison.Ordinal); + if (doubleNl > 0) + { + content = content[(doubleNl + 2)..]; + } + } + + list.Add(new AgentCommunicationDto( + TargetAgentId: agent.AgentId, + TargetAgentName: agent.DisplayName, + SourceAgentId: senderId, + SourceAgentName: senderName, + Role: entry.Role, + Content: content, + Timestamp: entry.Timestamp)); + } + } + + return Results.Ok(list.OrderBy(c => c.Timestamp).ToList()); + }); + agents.MapGet("/{agentId}", (AppHost host, string agentId) => host.AgentAdmin.Find(agentId) is { } agent ? Results.Ok(agent.ToDto( diff --git a/src/ClawdDotNet.Web/Endpoints/ControlEndpoints.cs b/src/ClawdDotNet.Web/Endpoints/ControlEndpoints.cs index 6dafca1..ae01b94 100644 --- a/src/ClawdDotNet.Web/Endpoints/ControlEndpoints.cs +++ b/src/ClawdDotNet.Web/Endpoints/ControlEndpoints.cs @@ -1,3 +1,5 @@ +using ClawdDotNet.App; +using ClawdDotNet.Core.Instances; using ClawdDotNet.Web.Security; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; @@ -5,6 +7,32 @@ using Microsoft.AspNetCore.Routing; namespace ClawdDotNet.Web.Endpoints; +/// Was noch offen ist, für die Puls-Auskunft. +public sealed record OffeneArbeitDto(string Name, int Anzahl); + +/// +/// Der Puls einer Instanz: Wer bin ich, lebe ich, und arbeite ich noch an etwas? +/// +/// Warum mehr als die Identität. Bis hierher fragte der Manager +/// /api/info und wusste danach nur, dass überhaupt jemand geantwortet hat. Das +/// reicht, um „läuft" von „tot" zu unterscheiden, aber nicht, um zwei Fälle +/// auseinanderzuhalten, die völlig verschieden zu behandeln sind: eine Instanz, die +/// hängt, und eine, die gerade geordnet aufräumt. Die erste gehört nach einer Frist +/// abgeschossen, die zweite in Ruhe gelassen. +/// +/// Die Kennung — der eigentliche Beweis, wer da antwortet. +/// "Running", "Draining" oder "Done". +/// Was gerade noch läuft. Leer heißt: nichts. +/// Wie lange das Auslaufen noch dauern darf. +public sealed record PulsDto( + string InstanceId, + string InstanceName, + string AppVersion, + string Phase, + IReadOnlyList OffeneArbeiten, + int OffenGesamt, + double RestsekundenFrist); + /// /// Was der Instanzmanager diesem Prozess sagen kann — und was der Prozess damit macht. /// @@ -64,6 +92,25 @@ internal static class ControlEndpoints { var control = app.MapGroup("/api/instanz"); + // Der Puls. Nur ueber den Socket - was hier steht, geht ausschliesslich den + // Instanzmanager etwas an, und er ist der Einzige, der diesen Weg hat. + control.MapGet("/puls", (HttpContext context, AppHost host) => + { + if (!LocalTransport.Applies(context)) + return Results.NotFound(); + + var stand = host.Shutdown.Snapshot(); + + return Results.Ok(new PulsDto( + host.Instance.InstanceId, + host.Instance.InstanceName, + AppHost.AppVersion, + stand.Phase.ToString(), + [.. stand.Open.Select(o => new OffeneArbeitDto(o.Name, o.Count))], + stand.TotalOpen, + Math.Round(stand.Remaining.TotalSeconds, 1))); + }); + control.MapPost("/beenden", (HttpContext context, InstanceControl steuerung) => { if (!LocalTransport.Applies(context)) diff --git a/tests/ClawdDotNet.Core.Tests/Instances/ShutdownCoordinatorTests.cs b/tests/ClawdDotNet.Core.Tests/Instances/ShutdownCoordinatorTests.cs new file mode 100644 index 0000000..1f88add --- /dev/null +++ b/tests/ClawdDotNet.Core.Tests/Instances/ShutdownCoordinatorTests.cs @@ -0,0 +1,160 @@ +using ClawdDotNet.Core.Instances; +using Microsoft.Extensions.Logging.Abstractions; +using Shouldly; + +namespace ClawdDotNet.Core.Tests.Instances; + +/// +/// Das geordnete Ende einer Instanz (#528). +/// +/// Worum es geht. Bis hierher war jedes Beenden ein Abschneiden. Eine +/// Aufgabe, die mitten in der Ausführung abgebrochen wird, ist bereits beansprucht und +/// noch nicht abgeschlossen — sie steht danach auf running und bleibt dort bis zum +/// Ablauf ihres Lease. Ein Agentenlauf verliert seine Antwort ganz. +/// +public sealed class ShutdownCoordinatorTests +{ + private static ShutdownCoordinator Koordinator(TimeSpan? frist = null) + => new(NullLogger.Instance, frist ?? TimeSpan.FromSeconds(5)); + + /// + /// Die Reihenfolge ist der ganze Trick: erst schließen, dann warten. + /// + /// Andersherum wartet man ewig — die Quelle nähme im nächsten Takt die nächste + /// Arbeit an, und die Zahl der offenen ginge nie auf null. + /// + [Fact] + public async Task Erst_wird_die_Tuer_geschlossen_dann_gewartet() + { + var geschlossen = false; + var offenBeimSchliessen = -1; + var offen = 3; + + var koordinator = Koordinator(); + + koordinator.Register(new WorkSource( + "Aufgaben", + () => offen, + () => + { + geschlossen = true; + offenBeimSchliessen = offen; + })); + + // Die Arbeiten laufen im Hintergrund aus. + _ = Task.Run(async () => + { + while (offen > 0) + { + await Task.Delay(30); + offen--; + } + }); + + await koordinator.BeginAsync(); + + geschlossen.ShouldBeTrue(); + offenBeimSchliessen.ShouldBe(3, "Geschlossen wird, bevor gewartet wird."); + koordinator.Phase.ShouldBe(ShutdownPhase.Done); + koordinator.Snapshot().TotalOpen.ShouldBe(0); + } + + /// + /// Ohne offene Arbeit endet es sofort — kein Warten aus Prinzip. + /// + [Fact] + public async Task Ohne_offene_Arbeit_endet_es_sofort() + { + var koordinator = Koordinator(TimeSpan.FromMinutes(10)); + koordinator.Register(new WorkSource("Aufgaben", () => 0, () => { })); + + var begonnen = DateTimeOffset.UtcNow; + await koordinator.BeginAsync(); + + (DateTimeOffset.UtcNow - begonnen).ShouldBeLessThan(TimeSpan.FromSeconds(2)); + koordinator.Phase.ShouldBe(ShutdownPhase.Done); + } + + /// + /// Die Frist ist eine Zusage, keine Hoffnung. + /// + /// Sonst hinge die Instanz an einem Agentenlauf, der auf ein Modell wartet, das + /// nicht antwortet — und niemand käme je zum Ende. + /// + [Fact] + public async Task Nach_der_Frist_endet_es_auch_mit_offener_Arbeit() + { + var koordinator = Koordinator(TimeSpan.FromMilliseconds(300)); + koordinator.Register(new WorkSource("Agentenläufe", () => 2, () => { })); + + await koordinator.BeginAsync(); + + koordinator.Phase.ShouldBe(ShutdownPhase.Done); + } + + /// + /// Während des Auslaufens sagt der Puls, was noch offen ist — daran erkennt der + /// Instanzmanager, dass hier aufgeräumt und nicht gehangen wird. + /// + [Fact] + public async Task Waehrend_des_Auslaufens_meldet_der_Stand_was_offen_ist() + { + var offen = 2; + var koordinator = Koordinator(TimeSpan.FromSeconds(5)); + koordinator.Register(new WorkSource("Agentenläufe", () => offen, () => { })); + + koordinator.Snapshot().Phase.ShouldBe(ShutdownPhase.Running); + + var lauf = koordinator.BeginAsync(); + + // Solange etwas offen ist, steht der Stand auf Draining und nennt die Zahl. + var stand = koordinator.Snapshot(); + stand.Phase.ShouldBe(ShutdownPhase.Draining); + stand.TotalOpen.ShouldBe(2); + stand.Open.Single().Name.ShouldBe("Agentenläufe"); + + offen = 0; + await lauf; + + koordinator.Snapshot().Phase.ShouldBe(ShutdownPhase.Done); + } + + /// + /// Zwei Aufrufer, ein Vorgang. + /// + /// Beide Wege gibt es wirklich: Der Manager bittet über den Socket, und + /// gleichzeitig kann jemand am Fenster auf das Kreuz klicken. Zweimal auszulaufen + /// hieße, die Tür zweimal zu schließen und zweimal zu warten. + /// + [Fact] + public async Task Ein_zweiter_Aufruf_wartet_auf_denselben_Vorgang() + { + var schliessungen = 0; + var koordinator = Koordinator(TimeSpan.FromSeconds(5)); + koordinator.Register(new WorkSource("Aufgaben", () => 0, () => schliessungen++)); + + await Task.WhenAll(koordinator.BeginAsync(), koordinator.BeginAsync()); + + schliessungen.ShouldBe(1); + } + + /// + /// Eine Quelle, die beim Zählen stolpert, darf das Ende nicht aufhalten. + /// + [Fact] + public async Task Eine_stolpernde_Quelle_haelt_das_Ende_nicht_auf() + { + var koordinator = Koordinator(TimeSpan.FromSeconds(30)); + + koordinator.Register(new WorkSource( + "Kaputt", + () => throw new InvalidOperationException("zählt nicht"), + () => throw new InvalidOperationException("schließt nicht"))); + + var begonnen = DateTimeOffset.UtcNow; + await koordinator.BeginAsync(); + + (DateTimeOffset.UtcNow - begonnen).ShouldBeLessThan(TimeSpan.FromSeconds(2)); + koordinator.Phase.ShouldBe(ShutdownPhase.Done); + } +} diff --git a/tests/ClawdDotNet.Manager.Tests/AutostartTests.cs b/tests/ClawdDotNet.Manager.Tests/AutostartTests.cs index ae78084..b9c9f2a 100644 --- a/tests/ClawdDotNet.Manager.Tests/AutostartTests.cs +++ b/tests/ClawdDotNet.Manager.Tests/AutostartTests.cs @@ -32,7 +32,9 @@ public sealed class AutostartTests : IAsyncDisposable ProbeInterval: TimeSpan.FromMilliseconds(50), StartTimeout: TimeSpan.FromMilliseconds(600), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromMilliseconds(300)); + StopGrace: TimeSpan.FromMilliseconds(300), + SilentKillGrace: TimeSpan.FromMilliseconds(300), + MaxDrainWait: TimeSpan.FromSeconds(2)); public AutostartTests() { @@ -175,6 +177,87 @@ public sealed class AutostartTests : IAsyncDisposable _launcher.Starts.ShouldBe(1, "Nur der Start von Hand, kein Neustart."); } + /// + /// Eine verstummte Instanz wird beendet und neu gestartet — aber erst, nachdem der + /// alte Prozess nachweislich weg ist. + /// + /// Der Fall wird hier wirklich hergestellt und nicht behauptet. Der + /// Prozess lebt weiter, nur der Socket schweigt — genau die Lage aus #529. Ein Test, + /// der stattdessen das Ereignis von Hand baut und die Neustartmethode aufruft, prüft + /// die eine Hälfte, die ohnehin funktioniert, und lässt die gefährliche aus: dass vor + /// dem Start niemand mehr auf der Datenbank sitzt. + /// + [Fact] + public async Task Eine_verstummte_Instanz_wird_erst_beendet_und_dann_neu_gestartet() + { + var pfad = Instanz("Alpha", autostart: true); + + await using var manager = Manager(); + await manager.StartAsync(); + + var alt = _launcher.Last.ShouldNotBeNull(); + _launcher.Starts.ShouldBe(1); + + // Ab jetzt haengt sie: Der Prozess lebt, der Socket antwortet nicht mehr. + _kanal.Verstummen(pfad); + + var aufsicht = manager.Instances.SupervisorFor(pfad).ShouldNotBeNull(); + + // Drei Durchgaenge bis zum Alarm - vorher wird nichts unternommen. + for (var i = 0; i < 3; i++) await aufsicht.CheckAsync(); + + aufsicht.Condition.ShouldBe(InstanceCondition.Silent); + alt.WasKilled.ShouldBeFalse("Vor Ablauf der Frist wird nicht abgeschossen."); + + // Die Frist laeuft ab (SilentKillGrace: 300ms). + await Task.Delay(400); + await aufsicht.CheckAsync(); + + alt.WasKilled.ShouldBeTrue("Nach der Frist wird der haengende Prozess beendet."); + + // Der Absturzweg startet neu - und der neue Prozess ist ein anderer. + await Warte(() => _launcher.Starts >= 2); + + _launcher.Last.ShouldNotBeNull().Id.ShouldNotBe(alt.Id); + alt.HasExited.ShouldBeTrue("Der alte Prozess darf beim Start nicht mehr leben."); + } + + /// + /// Eine Instanz, die aufräumt, wird nicht abgeschossen — auch wenn es dauert. + /// + /// Sie antwortet ja; sie tut genau das, worum gebeten wurde. Der Unterschied + /// zwischen „hängt" und „räumt auf" ist der ganze Grund, warum der Puls mehr sagt als + /// „jemand hat geantwortet". + /// + [Fact] + public async Task Wer_aufraeumt_gilt_nicht_als_verstummt() + { + var pfad = Instanz("Alpha", autostart: true); + + await using var manager = Manager(); + await manager.StartAsync(); + + var prozess = _launcher.Last.ShouldNotBeNull(); + + _kanal.AnswerFor[Path.GetFullPath(pfad)] = new InstanceIdentity( + "i-Alpha", "Alpha", "0.1.2", + ShutdownPhase.Draining, OpenWork: 2, OpenSummary: "Agentenläufe: 2"); + + var aufsicht = manager.Instances.SupervisorFor(pfad).ShouldNotBeNull(); + + for (var i = 0; i < 5; i++) await aufsicht.CheckAsync(); + + aufsicht.Condition.ShouldBe(InstanceCondition.Running); + prozess.WasKilled.ShouldBeFalse(); + _launcher.Starts.ShouldBe(1); + } + + private static async Task Warte(Func bedingung) + { + for (var i = 0; i < 100 && !bedingung(); i++) + await Task.Delay(20); + } + /// /// Nach der Grenze setzt der Manager aus. /// @@ -341,7 +424,9 @@ public sealed class StaleStateTests : IAsyncDisposable TimeSpan.FromSeconds(30), // absichtlich traege: kein Durchgang dazwischen TimeSpan.FromMilliseconds(600), 3, - TimeSpan.FromMilliseconds(300))); + TimeSpan.FromMilliseconds(300), + TimeSpan.FromMilliseconds(300), + TimeSpan.FromSeconds(2))); (await aufsicht.StartAsync()).ShouldBeTrue(); aufsicht.Condition.ShouldBe(InstanceCondition.Running); diff --git a/tests/ClawdDotNet.Manager.Tests/BackupManagementTests.cs b/tests/ClawdDotNet.Manager.Tests/BackupManagementTests.cs new file mode 100644 index 0000000..97635e0 --- /dev/null +++ b/tests/ClawdDotNet.Manager.Tests/BackupManagementTests.cs @@ -0,0 +1,96 @@ +using ClawdDotNet.Core.Backup; +using ClawdDotNet.Core.Config; +using ClawdDotNet.Core.Instances; +using Shouldly; + +namespace ClawdDotNet.Manager.Tests; + +/// +/// Tests für Sicherung und Wiederherstellung im Manager (#530, Stufe 6). +/// +public sealed class BackupManagementTests : IDisposable +{ + private readonly string _root = Path.Combine( + Path.GetTempPath(), "clawd-tests", "backup-" + Guid.NewGuid().ToString("N")[..8]); + + public BackupManagementTests() + { + Directory.CreateDirectory(_root); + } + + public void Dispose() + { + try { Directory.Delete(_root, recursive: true); } + catch { } + } + + [Fact] + public void BackupDirectory_wird_standardmaessig_unter_Backups_aufgeloest() + { + var instancePath = Path.Combine(_root, "TestInstance"); + Directory.CreateDirectory(instancePath); + + var config = new InstanceConfig { WorkingDirectory = instancePath }; + var backupDir = InstanceLayout.ResolveBackupDirectory(config, instancePath); + + backupDir.ShouldBe(Path.Combine(instancePath, "Backups")); + } + + [Fact] + public async Task Backup_kann_erstellt_geprueft_und_wiederhergestellt_werden() + { + var instancePath = Path.Combine(_root, "InstanceAlpha"); + Directory.CreateDirectory(instancePath); + + var settingsPath = Path.Combine(instancePath, "InstanceSettings.json"); + await File.WriteAllTextAsync(settingsPath, """ + { + "instanceId": "alpha-123", + "instanceName": "Alpha", + "workingDirectory": "" + } + """); + + var testDataPath = Path.Combine(instancePath, "data.txt"); + await File.WriteAllTextAsync(testDataPath, "Wichtige Testdaten"); + + var backupDir = InstanceLayout.ResolveBackupDirectory( + new InstanceConfig { WorkingDirectory = instancePath }, instancePath); + Directory.CreateDirectory(backupDir); + + var zipPath = Path.Combine(backupDir, "backup_Alpha_test.zip"); + + var service = new BackupService(); + var backupResult = await service.CreateAsync(instancePath, zipPath, new BackupOptions + { + Secrets = SecretMode.Exclude, + IncludeChatHistory = true, + IncludeLogs = false + }); + + File.Exists(zipPath).ShouldBeTrue(); + backupResult.SizeBytes.ShouldBeGreaterThan(0); + + // Prüfen + var manifest = await service.InspectAsync(zipPath); + manifest.InstanceId.ShouldBe("alpha-123"); + manifest.InstanceName.ShouldBe("Alpha"); + manifest.Files.Count.ShouldBeGreaterThan(0); + + // Datei im Ziel modifizieren und Restore prüfen + await File.WriteAllTextAsync(testDataPath, "Überschriebene Testdaten"); + + var restoreResult = await service.RestoreAsync( + zipPath, + instancePath, + new RestoreOptions { Overwrite = true }); + + restoreResult.Written.ShouldContain("data.txt"); + var restoredContent = await File.ReadAllTextAsync(testDataPath); + restoredContent.ShouldBe("Wichtige Testdaten"); + + // Löschen + File.Delete(zipPath); + File.Exists(zipPath).ShouldBeFalse(); + } +} diff --git a/tests/ClawdDotNet.Manager.Tests/Doubles.cs b/tests/ClawdDotNet.Manager.Tests/Doubles.cs index 780893a..f514947 100644 --- a/tests/ClawdDotNet.Manager.Tests/Doubles.cs +++ b/tests/ClawdDotNet.Manager.Tests/Doubles.cs @@ -76,6 +76,20 @@ internal sealed class FakeLauncher : IInstanceLauncher return Last; } + /// + /// Ein Prozess, der schon lief, bevor dieser Manager kam (E-M6). + /// + /// Zählt nicht als Start — genau darin liegt der Unterschied, den mehrere Tests + /// prüfen: Was läuft, wird übernommen und nicht ein zweites Mal hochgefahren. + /// + public FakeProcess Fremdstart(string instanceDirectory, int processId) + { + var prozess = new FakeProcess(processId, Now); + Running[processId] = prozess; + ByDirectory[Path.GetFullPath(instanceDirectory)] = prozess; + return prozess; + } + public IInstanceProcess? Attach(int processId, DateTimeOffset startedAt) { if (!Running.TryGetValue(processId, out var process)) @@ -120,6 +134,20 @@ internal sealed class FakeChannel : IInstanceChannel /// public FakeLauncher? Launcher { get; set; } + /// + /// Verzeichnisse, deren Instanz verstummt ist: Der Prozess lebt, der Socket schweigt. + /// + /// Der Fall aus #529 — und der einzige, in dem die Aufsicht von sich aus zur + /// Gewalt greift. Ohne diesen Schalter lässt er sich nicht nachstellen: Die Kopplung + /// an bindet die Antwort sonst genau an das, was hier + /// auseinanderfallen soll. + /// + public HashSet Verstummt { get; } = new(StringComparer.OrdinalIgnoreCase); + + /// Die Instanz hört auf zu antworten, ohne dass ihr Prozess endet. + public void Verstummen(string instanceDirectory) + => Verstummt.Add(Path.GetFullPath(instanceDirectory)); + public int Calls { get; private set; } /// Wie oft die Instanz gebeten wurde, sich zu beenden. @@ -132,6 +160,9 @@ internal sealed class FakeChannel : IInstanceChannel { Calls++; + if (Verstummt.Contains(Path.GetFullPath(instanceDirectory))) + return Task.FromResult(null); + if (Launcher is not null && !Launcher.IsRunning(instanceDirectory)) return Task.FromResult(null); diff --git a/tests/ClawdDotNet.Manager.Tests/InstanceRegistryTests.cs b/tests/ClawdDotNet.Manager.Tests/InstanceRegistryTests.cs index 76c90ee..076ff3b 100644 --- a/tests/ClawdDotNet.Manager.Tests/InstanceRegistryTests.cs +++ b/tests/ClawdDotNet.Manager.Tests/InstanceRegistryTests.cs @@ -27,10 +27,17 @@ public sealed class InstanceRegistryTests : IAsyncDisposable ProbeInterval: TimeSpan.FromMilliseconds(50), StartTimeout: TimeSpan.FromMilliseconds(600), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromMilliseconds(300)); + StopGrace: TimeSpan.FromMilliseconds(300), + SilentKillGrace: TimeSpan.FromMilliseconds(300), + MaxDrainWait: TimeSpan.FromSeconds(2)); public InstanceRegistryTests() - => _verzeichnisse = new InstanceDirectoryManager(Path.Combine(_root, "Instances")); + { + _verzeichnisse = new InstanceDirectoryManager(Path.Combine(_root, "Instances")); + // Der Socket antwortet nur, wenn wirklich ein Prozess laeuft - genau wie im + // Betrieb (siehe FakeChannel.Launcher). + _kanal.Launcher = _launcher; + } private InstanceRegistry Register() { diff --git a/tests/ClawdDotNet.Manager.Tests/InstanceSupervisorTests.cs b/tests/ClawdDotNet.Manager.Tests/InstanceSupervisorTests.cs index c614da2..c2dca95 100644 --- a/tests/ClawdDotNet.Manager.Tests/InstanceSupervisorTests.cs +++ b/tests/ClawdDotNet.Manager.Tests/InstanceSupervisorTests.cs @@ -1,3 +1,4 @@ +using ClawdDotNet.Core.Instances; using Microsoft.Extensions.Logging.Abstractions; using Shouldly; @@ -38,9 +39,19 @@ public sealed class InstanceSupervisorTests : IDisposable ProbeInterval: TimeSpan.FromMilliseconds(50), StartTimeout: TimeSpan.FromMilliseconds(600), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromMilliseconds(300)); + StopGrace: TimeSpan.FromMilliseconds(300), + SilentKillGrace: TimeSpan.FromMilliseconds(300), + MaxDrainWait: TimeSpan.FromSeconds(2)); - public InstanceSupervisorTests() => Directory.CreateDirectory(_dir); + public InstanceSupervisorTests() + { + Directory.CreateDirectory(_dir); + + // Der Socket antwortet nur, wenn wirklich ein Prozess laeuft - genau wie im + // Betrieb. Eine vorab hinterlegte Antwort hiesse sonst "laeuft schon", und die + // Aufsicht wuerde uebernehmen statt zu starten. + _kanal.Launcher = _launcher; + } public void Dispose() { @@ -252,6 +263,72 @@ public sealed class InstanceSupervisorTests : IDisposable aufsicht.Condition.ShouldBe(InstanceCondition.Stopped); } + /// + /// Schweigen ist kein Todesnachweis, solange ein Prozesshandle das Gegenteil sagt. + /// + /// Hier lag der gefährlichste Fehlschluss. Die Warteschleife brach ab, + /// sobald der Socket nicht mehr antwortete, meldete „beendet" und gab true + /// zurück — ohne den Prozess anzufassen. Bei einer verstummten Instanz ist der Socket + /// aber von vornherein still: Der Aufruf meldete sofort Erfolg, der Prozess lief + /// weiter, und der Neustart setzte einen zweiten auf dieselbe state.db. Genau + /// der Schaden, gegen den dieses Vorhaben gebaut ist. + /// + [Fact] + public async Task Ein_stummer_aber_lebender_Prozess_gilt_nicht_als_beendet() + { + _kanal.Answer = Test; + + await using var aufsicht = Aufsicht(); + await aufsicht.StartAsync(); + + var prozess = _launcher.Last.ShouldNotBeNull(); + + // Sie haengt: Der Socket schweigt, der Prozess lebt. + _kanal.Verstummen(_dir); + + (await aufsicht.StopAsync()).ShouldBeTrue(); + + prozess.WasKilled.ShouldBeTrue( + "Wer schweigt und lebt, muss beendet werden - nicht fuer beendet erklaert."); + + prozess.HasExited.ShouldBeTrue(); + aufsicht.Condition.ShouldBe(InstanceCondition.Stopped); + } + + /// + /// Wer aufräumt, wird nicht abgeschossen — die Frist wird nachgezogen. + /// + /// Die Instanz gibt sich selbst eine Frist zum Auslaufen. Wäre die des Managers + /// kürzer, schösse er mitten in das Aufräumen hinein, um das er gerade gebeten + /// hat. + /// + [Fact] + public async Task Wer_aufraeumt_bekommt_die_Frist_nachgezogen() + { + _kanal.Answer = Test; + + await using var aufsicht = Aufsicht(); + await aufsicht.StartAsync(); + + var prozess = _launcher.Last.ShouldNotBeNull(); + + // Sie antwortet und meldet: Ich raeume auf. Laenger als StopGrace (300ms), aber + // kuerzer als MaxDrainWait (2s). + _kanal.Answer = Test with { Phase = ShutdownPhase.Draining, OpenWork = 1 }; + + _ = Task.Run(async () => + { + await Task.Delay(700); + _kanal.Answer = null; + prozess.Exit(0); + }); + + (await aufsicht.StopAsync()).ShouldBeTrue(); + + prozess.WasKilled.ShouldBeFalse("Wer aufraeumt, wird nicht abgeschossen."); + aufsicht.Condition.ShouldBe(InstanceCondition.Stopped); + } + /// /// Eine Instanz, die der Manager nicht selbst gestartet hat und die nicht hört, kann /// er auch nicht beenden — und das muss er sagen, statt Erfolg zu melden. @@ -265,6 +342,10 @@ public sealed class InstanceSupervisorTests : IDisposable _kanal.Answer = Test; _kanal.StopRequestArrives = false; + // Sie lief schon, bevor dieser Manager kam - und ohne Zustandsdatei ist ihr + // Prozess fuer ihn nicht zu greifen. + _launcher.Fremdstart(_dir, 4711); + await using var aufsicht = Aufsicht(); await aufsicht.ReattachAsync(); // uebernommen, aber ohne Prozess aufsicht.ProcessId.ShouldBeNull(); @@ -356,6 +437,7 @@ public sealed class InstanceSupervisorTests : IDisposable // Der Fall nach einem Absturz des Managers, bevor er schreiben konnte - oder // nachdem jemand die Datei geloescht hat. Der Socket antwortet, also laeuft sie. _kanal.Answer = Test; + _launcher.Fremdstart(_dir, 4711); await using var aufsicht = Aufsicht(); (await aufsicht.ReattachAsync()).ShouldBeTrue(); diff --git a/tests/ClawdDotNet.Manager.Tests/ManagerCoreTests.cs b/tests/ClawdDotNet.Manager.Tests/ManagerCoreTests.cs index 2d1cee2..ad22252 100644 --- a/tests/ClawdDotNet.Manager.Tests/ManagerCoreTests.cs +++ b/tests/ClawdDotNet.Manager.Tests/ManagerCoreTests.cs @@ -41,12 +41,17 @@ public sealed class ManagerCoreTests : IAsyncDisposable ProbeInterval: TimeSpan.FromMilliseconds(50), StartTimeout: TimeSpan.FromMilliseconds(600), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromMilliseconds(300)); + StopGrace: TimeSpan.FromMilliseconds(300), + SilentKillGrace: TimeSpan.FromMilliseconds(300), + MaxDrainWait: TimeSpan.FromSeconds(2)); public ManagerCoreTests() { Directory.CreateDirectory(_root); _verzeichnisse = new InstanceDirectoryManager(Path.Combine(_root, "Instances")); + // Der Socket antwortet nur, wenn wirklich ein Prozess laeuft - genau wie im + // Betrieb (siehe FakeChannel.Launcher). + _kanal.Launcher = _launcher; } private ManagerCore Manager() @@ -239,12 +244,17 @@ public sealed class InstanceFocusTests : IAsyncDisposable ProbeInterval: TimeSpan.FromMilliseconds(50), StartTimeout: TimeSpan.FromMilliseconds(600), SilentChecksBeforeAlarm: 3, - StopGrace: TimeSpan.FromMilliseconds(300)); + StopGrace: TimeSpan.FromMilliseconds(300), + SilentKillGrace: TimeSpan.FromMilliseconds(300), + MaxDrainWait: TimeSpan.FromSeconds(2)); public InstanceFocusTests() { Directory.CreateDirectory(_root); _verzeichnisse = new InstanceDirectoryManager(Path.Combine(_root, "Instances")); + // Der Socket antwortet nur, wenn wirklich ein Prozess laeuft - genau wie im + // Betrieb (siehe FakeChannel.Launcher). + _kanal.Launcher = _launcher; } private InstanceRegistry Register() => new( diff --git a/tests/ClawdDotNet.Web.Tests/AgentCommunicationTests.cs b/tests/ClawdDotNet.Web.Tests/AgentCommunicationTests.cs new file mode 100644 index 0000000..5ced8b6 --- /dev/null +++ b/tests/ClawdDotNet.Web.Tests/AgentCommunicationTests.cs @@ -0,0 +1,32 @@ +using ClawdDotNet.Web.Contracts; +using Shouldly; + +namespace ClawdDotNet.Web.Tests; + +/// +/// Tests für die interne Agenten-Kommunikation A2A (#208). +/// +public sealed class AgentCommunicationTests +{ + [Fact] + public void AgentCommunicationDto_speichert_Felder_korrekt() + { + var now = DateTime.UtcNow; + var dto = new AgentCommunicationDto( + TargetAgentId: "editor-1", + TargetAgentName: "Editor", + SourceAgentId: "scout-1", + SourceAgentName: "Scout", + Role: "user", + Content: "Bitte bearbeite Datei X", + Timestamp: now); + + dto.TargetAgentId.ShouldBe("editor-1"); + dto.TargetAgentName.ShouldBe("Editor"); + dto.SourceAgentId.ShouldBe("scout-1"); + dto.SourceAgentName.ShouldBe("Scout"); + dto.Role.ShouldBe("user"); + dto.Content.ShouldBe("Bitte bearbeite Datei X"); + dto.Timestamp.ShouldBe(now); + } +}