ClawdDotNet/src/ClawdDotNet.Core/Deploymentcenter/TokenProvisioner.cs

using System.Text.Json;

namespace ClawdDotNet.Core.Deploymentcenter;

/// <summary>Ein für diese Instanz ausgestelltes Sub-Token.</summary>
/// <param name="Token">Der Klartext — wird nur einmal ausgeliefert.</param>
/// <param name="TokenId">Kennung zum Widerrufen in der Verwaltung.</param>
/// <param name="Scopes">Welche Rechte tatsächlich durchgereicht wurden.</param>
public sealed record ProvisionedToken(string Token, string TokenId, IReadOnlyList<string> Scopes);

/// <summary>
/// Was ein Token über sich selbst sagt (<c>GET /api/tokens/v1/whoami</c>, seit SDK 2.7.1).
///
/// <para><see cref="ProjectSlug"/> ist das Feld, auf das es ankommt. Seit SDK 2.8.1 erbt
/// ein Watchdog-Monitor das Projekt seines Ping-Tokens — ist dort nichts eingetragen,
/// landen die Befunde im Scheinprojekt „default", und eine Abfrage nach dem eigenen
/// Projekt liefert für eine laufende, meldende Instanz <b>null Befunde</b>. Die Aufsicht
/// sähe dann aus wie „nichts auffällig", und das ist der schlechteste aller
/// Irrtümer.</para>
/// </summary>
public sealed record TokenIdentity(
    string TokenId,
    string Name,
    string Type,
    string? ProjectSlug,
    string Environment,
    IReadOnlyList<string> Scopes)
{
    /// <summary>Ob dieses Token an ein Projekt gebunden ist — siehe Klassenkommentar.</summary>
    public bool IsProjectBound => !string.IsNullOrWhiteSpace(ProjectSlug);
}

/// <summary>
/// Der Zugang zu <c>/api/tokens/v1/…</c>: ein Sub-Token je Instanz ausstellen
/// (<c>provision</c>) und ein Token nach sich selbst fragen (<c>whoami</c>).
///
/// <para>Das ersetzt die frühere Selbstregistrierung über <c>POST /api/register</c> —
/// diesen Endpunkt gibt es im Deploymentcenter nicht (und im alten WatchDog-Server war
/// er der einzige Weg, überhaupt an einen Token zu kommen). Der Zweck bleibt derselbe
/// und ist es wert, erhalten zu bleiben: Auf den Instanzen liegt danach nicht das
/// Master-Token, sondern ein eingeschränktes, einzeln widerrufbares.</para>
///
/// <para>Rechte lassen sich dabei nur einschränken, nie erweitern — was das
/// Master-Token nicht hat, bekommt auch das Sub-Token nicht.</para>
/// </summary>
public sealed class TokenProvisioner(DeploymentcenterApi api)
{
    /// <summary>Was eine Instanz braucht: Heartbeats senden und Fehler melden.</summary>
    public static readonly string[] InstanceScopes = ["watchdog:ping", "bugtracker:report"];

    public async Task<ProvisionedToken> ProvisionAsync(
        string clientName,
        string instanceId,
        IReadOnlyList<string> scopes,
        string environment = "production",
        CancellationToken ct = default)
    {
        var payload = new
        {
            client_name = clientName,
            instance_id = instanceId,
            scopes,
            environment
        };

        var response = await api.PostAsync("/api/tokens/v1/provision", payload, ct)
            .ConfigureAwait(false);

        var token = response.TryGetProperty("sub_token", out var t) && t.ValueKind == JsonValueKind.String
            ? t.GetString()
            : null;

        if (string.IsNullOrWhiteSpace(token))
        {
            throw new DeploymentcenterException(
                "no_token",
                "Die Provisionierung lieferte kein Token.",
                System.Net.HttpStatusCode.OK);
        }

        var tokenId = response.TryGetProperty("token_id", out var i) && i.ValueKind == JsonValueKind.String
            ? i.GetString() ?? ""
            : "";

        var granted = new List<string>();
        if (response.TryGetProperty("scopes", out var s) && s.ValueKind == JsonValueKind.Array)
        {
            granted.AddRange(s.EnumerateArray()
                .Where(e => e.ValueKind == JsonValueKind.String)
                .Select(e => e.GetString()!));
        }

        return new ProvisionedToken(token, tokenId, granted);
    }

    /// <summary>
    /// Fragt das Token, mit dem diese Verbindung arbeitet, nach sich selbst.
    ///
    /// <para>Nicht Neugier, sondern die einzige Möglichkeit, die Projektbindung zu
    /// erfahren: Sie steht nicht im Token und ergibt sich nicht aus dem, was beim
    /// Ausstellen mitgeschickt wurde — sie ist eine Eigenschaft, die der Server führt.
    /// Siehe <see cref="TokenIdentity"/>, warum das nicht gleichgültig ist.</para>
    /// </summary>
    public async Task<TokenIdentity> WhoAmIAsync(CancellationToken ct = default)
    {
        var response = await api.GetAsync("/api/tokens/v1/whoami", ct).ConfigureAwait(false);

        var scopes = new List<string>();
        if (response.TryGetProperty("scopes", out var s) && s.ValueKind == JsonValueKind.Array)
        {
            scopes.AddRange(s.EnumerateArray()
                .Where(e => e.ValueKind == JsonValueKind.String)
                .Select(e => e.GetString()!));
        }

        return new TokenIdentity(
            Text(response, "token_id") ?? "",
            Text(response, "name") ?? "",
            Text(response, "type") ?? "unknown",
            Text(response, "project_slug"),
            Text(response, "environment") ?? "",
            scopes);
    }

    /// <summary>Eine Zeichenkette aus der Antwort; <c>null</c> auch bei JSON-<c>null</c>.</summary>
    private static string? Text(JsonElement root, string name)
        => root.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String
            ? v.GetString()
            : null;
}