@privateclaw/privateclaw-relay 0.1.6 → 0.1.8

package/dist/admin-metrics-store.js

@@ -0,0 +1,952 @@
+import { Redis } from "ioredis";
+const ADMIN_PREFIX = "privateclaw:admin:v1";
+const SESSION_INDEX_KEY = `${ADMIN_PREFIX}:sessions:index`;
+const INSTANCE_INDEX_KEY = `${ADMIN_PREFIX}:instances:index`;
+const GLOBAL_STATS_KEY = `${ADMIN_PREFIX}:stats:global`;
+const ERROR_CODE_COUNTS_KEY = `${ADMIN_PREFIX}:stats:error-codes`;
+const REQUEST_TYPE_COUNTS_KEY_PREFIX = `${ADMIN_PREFIX}:stats:request-types`;
+const INSTANCE_TTL_MS = 60_000;
+function sessionKey(sessionId) {
+    return `${ADMIN_PREFIX}:session:${sessionId}`;
+}
+function sessionParticipantsKey(sessionId) {
+    return `${ADMIN_PREFIX}:session:${sessionId}:participants`;
+}
+function sessionParticipantKey(sessionId, appId) {
+    return `${ADMIN_PREFIX}:session:${sessionId}:participant:${appId}`;
+}
+function instanceKey(instanceId) {
+    return `${ADMIN_PREFIX}:instance:${instanceId}`;
+}
+function requestTypeCountsKey(actor) {
+    return `${REQUEST_TYPE_COUNTS_KEY_PREFIX}:${actor}`;
+}
+function parseInteger(value) {
+    if (!value) {
+        return 0;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseOptionalInteger(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseBooleanFlag(value) {
+    return value === "1";
+}
+function normalizeSessionStatus(session, now) {
+    if (typeof session.closedAt === "number") {
+        return "closed";
+    }
+    if (session.expiresAt <= now) {
+        return "expired";
+    }
+    return "active";
+}
+function dedupeStrings(values) {
+    return [...new Set(values.filter((value) => value.trim() !== ""))].sort();
+}
+function dedupeBindings(bindings) {
+    const seen = new Set();
+    const normalized = [];
+    for (const binding of bindings) {
+        const sessionId = binding.sessionId.trim();
+        const appId = binding.appId.trim();
+        if (!sessionId || !appId) {
+            continue;
+        }
+        const key = `${sessionId}:${appId}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push({ sessionId, appId });
+    }
+    normalized.sort((left, right) => left.sessionId.localeCompare(right.sessionId) || left.appId.localeCompare(right.appId));
+    return normalized;
+}
+function toSerializableMemoryUsage(usage) {
+    return {
+        rss: usage.rss,
+        heapTotal: usage.heapTotal,
+        heapUsed: usage.heapUsed,
+        external: usage.external,
+        arrayBuffers: usage.arrayBuffers,
+    };
+}
+function createEmptyRequestStats() {
+    return {
+        appRequests: 0,
+        providerRequests: 0,
+        appSuccesses: 0,
+        providerSuccesses: 0,
+        appErrors: 0,
+        providerErrors: 0,
+        appFrames: 0,
+        providerFrames: 0,
+        errorCodes: [],
+        requestTypes: [],
+    };
+}
+function createLiveState(instances) {
+    const providerIds = new Set();
+    const participantKeys = new Set();
+    const activeParticipantCountBySession = new Map();
+    for (const instance of instances) {
+        for (const providerId of instance.providerIds) {
+            providerIds.add(providerId);
+        }
+        for (const binding of instance.participantBindings) {
+            const key = `${binding.sessionId}:${binding.appId}`;
+            if (participantKeys.has(key)) {
+                continue;
+            }
+            participantKeys.add(key);
+            activeParticipantCountBySession.set(binding.sessionId, (activeParticipantCountBySession.get(binding.sessionId) ?? 0) + 1);
+        }
+    }
+    return {
+        providerIds,
+        participantKeys,
+        activeParticipantCountBySession,
+    };
+}
+function toSessionSummary(params) {
+    const { session, liveState, now } = params;
+    return {
+        sessionId: session.sessionId,
+        providerId: session.providerId,
+        groupMode: session.groupMode,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        expiresAt: session.expiresAt,
+        ...(typeof session.closedAt === "number" ? { closedAt: session.closedAt } : {}),
+        ...(session.closeReason ? { closeReason: session.closeReason } : {}),
+        status: normalizeSessionStatus(session, now),
+        appMessageCount: session.appMessageCount,
+        providerMessageCount: session.providerMessageCount,
+        distinctParticipantCount: session.distinctParticipantCount,
+        activeParticipantCount: liveState.activeParticipantCountBySession.get(session.sessionId) ?? 0,
+        providerOnline: liveState.providerIds.has(session.providerId),
+        ...(typeof session.lastAppMessageAt === "number"
+            ? { lastAppMessageAt: session.lastAppMessageAt }
+            : {}),
+        ...(typeof session.lastProviderMessageAt === "number"
+            ? { lastProviderMessageAt: session.lastProviderMessageAt }
+            : {}),
+    };
+}
+function toParticipantSummary(params) {
+    const { sessionId, participant, liveState, now } = params;
+    const participantKeyValue = `${sessionId}:${participant.appId}`;
+    const isOnline = liveState.participantKeys.has(participantKeyValue);
+    const currentlyConnectedSince = participant.lastConnectedAt;
+    const disconnectedAt = participant.lastDisconnectedAt;
+    let currentConnectedMs = participant.totalConnectedMs;
+    if (typeof currentlyConnectedSince === "number") {
+        if (isOnline) {
+            currentConnectedMs += Math.max(now - currentlyConnectedSince, 0);
+        }
+        else if (typeof disconnectedAt !== "number" ||
+            disconnectedAt < currentlyConnectedSince) {
+            currentConnectedMs += Math.max(Math.max(participant.lastSeenAt, currentlyConnectedSince) - currentlyConnectedSince, 0);
+        }
+    }
+    return {
+        appId: participant.appId,
+        firstSeenAt: participant.firstSeenAt,
+        lastSeenAt: participant.lastSeenAt,
+        ...(typeof participant.lastConnectedAt === "number"
+            ? { lastConnectedAt: participant.lastConnectedAt }
+            : {}),
+        ...(typeof participant.lastDisconnectedAt === "number"
+            ? { lastDisconnectedAt: participant.lastDisconnectedAt }
+            : {}),
+        ...(participant.lastDisconnectReason
+            ? { lastDisconnectReason: participant.lastDisconnectReason }
+            : {}),
+        connectionCount: participant.connectionCount,
+        messageCount: participant.messageCount,
+        totalConnectedMs: participant.totalConnectedMs,
+        currentConnectedMs,
+        isOnline,
+    };
+}
+function sortParticipants(left, right) {
+    if (left.isOnline !== right.isOnline) {
+        return left.isOnline ? -1 : 1;
+    }
+    return right.lastSeenAt - left.lastSeenAt || left.appId.localeCompare(right.appId);
+}
+function normalizePage(page) {
+    return Number.isInteger(page) && page && page > 0 ? page : 1;
+}
+function normalizePageSize(pageSize) {
+    if (!Number.isInteger(pageSize) || !pageSize || pageSize <= 0) {
+        return 50;
+    }
+    return Math.min(pageSize, 200);
+}
+function matchesSessionQuery(session, query) {
+    if (!query) {
+        return true;
+    }
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return true;
+    }
+    return (session.sessionId.toLowerCase().includes(normalizedQuery) ||
+        session.providerId.toLowerCase().includes(normalizedQuery));
+}
+function collectOverviewTotals(sessions, instances) {
+    let activeSessions = 0;
+    let closedSessions = 0;
+    let expiredSessions = 0;
+    let knownParticipants = 0;
+    let activeParticipants = 0;
+    for (const session of sessions) {
+        if (session.status === "active") {
+            activeSessions += 1;
+        }
+        else if (session.status === "closed") {
+            closedSessions += 1;
+        }
+        else {
+            expiredSessions += 1;
+        }
+        knownParticipants += session.distinctParticipantCount;
+        activeParticipants += session.activeParticipantCount;
+    }
+    return {
+        sessions: sessions.length,
+        activeSessions,
+        closedSessions,
+        expiredSessions,
+        knownParticipants,
+        activeParticipants,
+        instances: instances.length,
+    };
+}
+function decodeRequestTypeCounts(actor, raw) {
+    const counts = new Map();
+    for (const [field, value] of Object.entries(raw)) {
+        const separatorIndex = field.lastIndexOf(":");
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const type = field.slice(0, separatorIndex);
+        const status = field.slice(separatorIndex + 1);
+        const entry = counts.get(type) ?? { actor, type, ok: 0, error: 0 };
+        if (status === "ok") {
+            entry.ok = parseInteger(value);
+        }
+        else if (status === "error") {
+            entry.error = parseInteger(value);
+        }
+        counts.set(type, entry);
+    }
+    return [...counts.values()].sort((left, right) => right.ok + right.error - (left.ok + left.error) || left.type.localeCompare(right.type));
+}
+function decodeErrorCodeCounts(raw) {
+    return Object.entries(raw)
+        .map(([code, value]) => ({ code, count: parseInteger(value) }))
+        .filter((entry) => entry.count > 0)
+        .sort((left, right) => right.count - left.count || left.code.localeCompare(right.code));
+}
+function decodeSessionHash(sessionId, hash) {
+    if (Object.keys(hash).length === 0) {
+        return undefined;
+    }
+    return {
+        sessionId,
+        providerId: hash.providerId ?? "unknown-provider",
+        groupMode: parseBooleanFlag(hash.groupMode),
+        createdAt: parseInteger(hash.createdAt),
+        updatedAt: parseInteger(hash.updatedAt),
+        expiresAt: parseInteger(hash.expiresAt),
+        ...(hash.closedAt ? { closedAt: parseInteger(hash.closedAt) } : {}),
+        ...(hash.closeReason ? { closeReason: hash.closeReason } : {}),
+        appMessageCount: parseInteger(hash.appMessageCount),
+        providerMessageCount: parseInteger(hash.providerMessageCount),
+        distinctParticipantCount: parseInteger(hash.distinctParticipantCount),
+        ...(hash.lastAppMessageAt
+            ? { lastAppMessageAt: parseInteger(hash.lastAppMessageAt) }
+            : {}),
+        ...(hash.lastProviderMessageAt
+            ? { lastProviderMessageAt: parseInteger(hash.lastProviderMessageAt) }
+            : {}),
+    };
+}
+function decodeParticipantHash(appId, hash) {
+    if (Object.keys(hash).length === 0) {
+        return undefined;
+    }
+    return {
+        appId,
+        firstSeenAt: parseInteger(hash.firstSeenAt),
+        lastSeenAt: parseInteger(hash.lastSeenAt),
+        ...(hash.lastConnectedAt
+            ? { lastConnectedAt: parseInteger(hash.lastConnectedAt) }
+            : {}),
+        ...(hash.lastDisconnectedAt
+            ? { lastDisconnectedAt: parseInteger(hash.lastDisconnectedAt) }
+            : {}),
+        ...(hash.lastDisconnectReason
+            ? { lastDisconnectReason: hash.lastDisconnectReason }
+            : {}),
+        connectionCount: parseInteger(hash.connectionCount),
+        messageCount: parseInteger(hash.messageCount),
+        totalConnectedMs: parseInteger(hash.totalConnectedMs),
+    };
+}
+function decodeInstanceHash(instanceId, hash) {
+    if (Object.keys(hash).length === 0) {
+        return undefined;
+    }
+    return {
+        instanceId,
+        startedAt: parseInteger(hash.startedAt),
+        lastSeenAt: parseInteger(hash.lastSeenAt),
+        activeProviders: parseInteger(hash.activeProviders),
+        activeApps: parseInteger(hash.activeApps),
+        localSessions: parseInteger(hash.localSessions),
+        providerIds: hash.providerIdsJson
+            ? JSON.parse(hash.providerIdsJson)
+            : [],
+        sessionIds: hash.sessionIdsJson
+            ? JSON.parse(hash.sessionIdsJson)
+            : [],
+        participantBindings: hash.participantBindingsJson
+            ? JSON.parse(hash.participantBindingsJson)
+            : [],
+        memoryUsage: hash.memoryUsageJson
+            ? JSON.parse(hash.memoryUsageJson)
+            : {
+                rss: 0,
+                heapTotal: 0,
+                heapUsed: 0,
+                external: 0,
+                arrayBuffers: 0,
+            },
+    };
+}
+class BaseRelayAdminMetricsStore {
+    buildOverview(params) {
+        return {
+            generatedAt: params.generatedAt,
+            totals: collectOverviewTotals(params.sessions, params.instances),
+            requestStats: params.requestStats,
+        };
+    }
+}
+export class InMemoryRelayAdminMetricsStore extends BaseRelayAdminMetricsStore {
+    persistent = false;
+    sessions = new Map();
+    participants = new Map();
+    instances = new Map();
+    errorCodeCounts = new Map();
+    requestTypeCounts = {
+        app: new Map(),
+        provider: new Map(),
+    };
+    globalStats = {
+        appRequests: 0,
+        providerRequests: 0,
+        appSuccesses: 0,
+        providerSuccesses: 0,
+        appErrors: 0,
+        providerErrors: 0,
+        appFrames: 0,
+        providerFrames: 0,
+    };
+    ensureSession(session, recordedAt) {
+        const existing = this.sessions.get(session.sessionId);
+        if (existing) {
+            existing.providerId = session.providerId;
+            existing.groupMode = session.groupMode;
+            existing.expiresAt = session.expiresAt;
+            existing.updatedAt = Math.max(existing.updatedAt, recordedAt);
+            return existing;
+        }
+        const created = {
+            sessionId: session.sessionId,
+            providerId: session.providerId,
+            groupMode: session.groupMode,
+            createdAt: recordedAt,
+            updatedAt: recordedAt,
+            expiresAt: session.expiresAt,
+            appMessageCount: 0,
+            providerMessageCount: 0,
+            distinctParticipantCount: 0,
+        };
+        this.sessions.set(session.sessionId, created);
+        return created;
+    }
+    ensureParticipant(sessionId, appId, recordedAt) {
+        const sessionParticipants = this.participants.get(sessionId) ?? new Map();
+        this.participants.set(sessionId, sessionParticipants);
+        const existing = sessionParticipants.get(appId);
+        if (existing) {
+            return { participant: existing, isNew: false };
+        }
+        const created = {
+            appId,
+            firstSeenAt: recordedAt,
+            lastSeenAt: recordedAt,
+            connectionCount: 0,
+            messageCount: 0,
+            totalConnectedMs: 0,
+        };
+        sessionParticipants.set(appId, created);
+        return { participant: created, isNew: true };
+    }
+    activeInstances(now) {
+        const cutoff = now - INSTANCE_TTL_MS;
+        for (const [instanceId, instance] of this.instances.entries()) {
+            if (instance.lastSeenAt <= cutoff) {
+                this.instances.delete(instanceId);
+            }
+        }
+        return [...this.instances.values()].sort((left, right) => right.lastSeenAt - left.lastSeenAt || left.instanceId.localeCompare(right.instanceId));
+    }
+    liveState(now) {
+        return createLiveState(this.activeInstances(now));
+    }
+    requestStats() {
+        return {
+            ...this.globalStats,
+            errorCodes: [...this.errorCodeCounts.entries()]
+                .map(([code, count]) => ({ code, count }))
+                .sort((left, right) => right.count - left.count || left.code.localeCompare(right.code)),
+            requestTypes: [
+                ...this.requestTypeCounts.app.values(),
+                ...this.requestTypeCounts.provider.values(),
+            ].sort((left, right) => right.ok + right.error - (left.ok + left.error) || left.type.localeCompare(right.type)),
+        };
+    }
+    async recordSessionCreated(session, recordedAt) {
+        this.ensureSession(session, recordedAt);
+    }
+    async recordSessionRenewed(session, recordedAt) {
+        this.ensureSession(session, recordedAt);
+    }
+    async recordSessionClosed(sessionId, reason, recordedAt) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.closedAt = recordedAt;
+        session.closeReason = reason;
+        session.updatedAt = recordedAt;
+    }
+    async recordAppAttached(session, appId, recordedAt) {
+        const sessionRecord = this.ensureSession(session, recordedAt);
+        const { participant, isNew } = this.ensureParticipant(session.sessionId, appId, recordedAt);
+        participant.lastSeenAt = recordedAt;
+        if (typeof participant.lastConnectedAt !== "number" ||
+            (typeof participant.lastDisconnectedAt === "number" &&
+                participant.lastDisconnectedAt >= participant.lastConnectedAt)) {
+            participant.connectionCount += 1;
+            participant.lastConnectedAt = recordedAt;
+        }
+        if (isNew) {
+            sessionRecord.distinctParticipantCount += 1;
+        }
+        sessionRecord.updatedAt = recordedAt;
+    }
+    async recordAppDetached(sessionId, appId, recordedAt, reason) {
+        const participant = this.participants.get(sessionId)?.get(appId);
+        if (!participant) {
+            return;
+        }
+        if (typeof participant.lastConnectedAt === "number" &&
+            (typeof participant.lastDisconnectedAt !== "number" ||
+                participant.lastDisconnectedAt < participant.lastConnectedAt)) {
+            participant.totalConnectedMs += Math.max(recordedAt - participant.lastConnectedAt, 0);
+        }
+        participant.lastDisconnectedAt = recordedAt;
+        participant.lastDisconnectReason = reason;
+        participant.lastSeenAt = recordedAt;
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.updatedAt = recordedAt;
+        }
+    }
+    async recordAppFrame(sessionId, appId, recordedAt) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.appMessageCount += 1;
+            session.lastAppMessageAt = recordedAt;
+            session.updatedAt = recordedAt;
+        }
+        const participant = this.participants.get(sessionId)?.get(appId);
+        if (participant) {
+            participant.messageCount += 1;
+            participant.lastSeenAt = recordedAt;
+        }
+        this.globalStats.appFrames += 1;
+    }
+    async recordProviderFrame(sessionId, recordedAt) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.providerMessageCount += 1;
+        session.lastProviderMessageAt = recordedAt;
+        session.updatedAt = recordedAt;
+        this.globalStats.providerFrames += 1;
+    }
+    async recordRequest(params) {
+        const actorStatsField = params.actor === "app" ? "app" : "provider";
+        this.globalStats[`${actorStatsField}Requests`] += 1;
+        if (params.ok) {
+            this.globalStats[`${actorStatsField}Successes`] += 1;
+        }
+        else {
+            this.globalStats[`${actorStatsField}Errors`] += 1;
+            if (params.errorCode) {
+                this.errorCodeCounts.set(params.errorCode, (this.errorCodeCounts.get(params.errorCode) ?? 0) + 1);
+            }
+        }
+        const requestTypeCounts = this.requestTypeCounts[params.actor];
+        const entry = requestTypeCounts.get(params.type) ?? {
+            actor: params.actor,
+            type: params.type,
+            ok: 0,
+            error: 0,
+        };
+        if (params.ok) {
+            entry.ok += 1;
+        }
+        else {
+            entry.error += 1;
+        }
+        requestTypeCounts.set(params.type, entry);
+    }
+    async recordInstanceHeartbeat(heartbeat) {
+        for (const binding of heartbeat.snapshot.participantBindings) {
+            const participant = this.participants.get(binding.sessionId)?.get(binding.appId);
+            if (participant) {
+                participant.lastSeenAt = heartbeat.recordedAt;
+            }
+        }
+        this.instances.set(heartbeat.instanceId, {
+            instanceId: heartbeat.instanceId,
+            startedAt: heartbeat.startedAt,
+            lastSeenAt: heartbeat.recordedAt,
+            activeProviders: heartbeat.snapshot.activeProviders,
+            activeApps: heartbeat.snapshot.activeApps,
+            localSessions: heartbeat.snapshot.localSessions,
+            providerIds: dedupeStrings(heartbeat.snapshot.providerIds),
+            sessionIds: dedupeStrings(heartbeat.snapshot.sessionIds),
+            participantBindings: dedupeBindings(heartbeat.snapshot.participantBindings),
+            memoryUsage: toSerializableMemoryUsage(heartbeat.snapshot.memoryUsage),
+        });
+    }
+    async unregisterInstance(instanceId) {
+        this.instances.delete(instanceId);
+    }
+    async listSessions(options = {}) {
+        const now = options.now ?? Date.now();
+        const liveState = this.liveState(now);
+        const page = normalizePage(options.page);
+        const pageSize = normalizePageSize(options.pageSize);
+        const allSessions = [...this.sessions.values()]
+            .map((session) => toSessionSummary({ session, liveState, now }))
+            .filter((session) => options.status && options.status !== "all"
+            ? session.status === options.status
+            : true)
+            .filter((session) => matchesSessionQuery(session, options.query))
+            .sort((left, right) => right.createdAt - left.createdAt || left.sessionId.localeCompare(right.sessionId));
+        const startIndex = (page - 1) * pageSize;
+        return {
+            total: allSessions.length,
+            page,
+            pageSize,
+            sessions: allSessions.slice(startIndex, startIndex + pageSize),
+        };
+    }
+    async getSessionDetail(sessionId, now = Date.now()) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        const liveState = this.liveState(now);
+        const sessionSummary = toSessionSummary({ session, liveState, now });
+        const participants = [
+            ...(this.participants.get(sessionId)?.values() ?? []),
+        ]
+            .map((participant) => toParticipantSummary({
+            sessionId,
+            participant,
+            liveState,
+            now,
+        }))
+            .sort(sortParticipants);
+        return {
+            session: sessionSummary,
+            participants,
+        };
+    }
+    async getOverview(now = Date.now()) {
+        const instances = this.activeInstances(now);
+        const liveState = createLiveState(instances);
+        const sessions = [...this.sessions.values()]
+            .map((session) => toSessionSummary({ session, liveState, now }))
+            .sort((left, right) => right.createdAt - left.createdAt || left.sessionId.localeCompare(right.sessionId));
+        return this.buildOverview({
+            sessions,
+            instances,
+            requestStats: this.requestStats(),
+            generatedAt: now,
+        });
+    }
+    async listInstances(now = Date.now()) {
+        return this.activeInstances(now);
+    }
+    async close() {
+        this.sessions.clear();
+        this.participants.clear();
+        this.instances.clear();
+        this.errorCodeCounts.clear();
+        this.requestTypeCounts.app.clear();
+        this.requestTypeCounts.provider.clear();
+    }
+}
+export class RedisRelayAdminMetricsStore extends BaseRelayAdminMetricsStore {
+    persistent = true;
+    redis;
+    constructor(redisUrl) {
+        super();
+        this.redis = new Redis(redisUrl, {
+            lazyConnect: false,
+            maxRetriesPerRequest: 1,
+        });
+    }
+    async ensureSession(session, recordedAt) {
+        const key = sessionKey(session.sessionId);
+        const existingCreatedAt = await this.redis.hget(key, "createdAt");
+        await this.redis
+            .multi()
+            .hset(key, {
+            sessionId: session.sessionId,
+            providerId: session.providerId,
+            groupMode: session.groupMode ? "1" : "0",
+            createdAt: existingCreatedAt ?? String(recordedAt),
+            updatedAt: String(recordedAt),
+            expiresAt: String(session.expiresAt),
+        })
+            .hsetnx(key, "appMessageCount", "0")
+            .hsetnx(key, "providerMessageCount", "0")
+            .hsetnx(key, "distinctParticipantCount", "0")
+            .zadd(SESSION_INDEX_KEY, String(existingCreatedAt ?? recordedAt), session.sessionId)
+            .exec();
+    }
+    async loadSession(sessionId) {
+        return decodeSessionHash(sessionId, await this.redis.hgetall(sessionKey(sessionId)));
+    }
+    async loadParticipant(sessionId, appId) {
+        return decodeParticipantHash(appId, await this.redis.hgetall(sessionParticipantKey(sessionId, appId)));
+    }
+    async pruneStaleInstances(now) {
+        const cutoff = now - INSTANCE_TTL_MS;
+        const staleIds = await this.redis.zrangebyscore(INSTANCE_INDEX_KEY, 0, cutoff);
+        if (staleIds.length === 0) {
+            return;
+        }
+        const pipeline = this.redis.multi();
+        pipeline.zrem(INSTANCE_INDEX_KEY, ...staleIds);
+        for (const staleId of staleIds) {
+            pipeline.del(instanceKey(staleId));
+        }
+        await pipeline.exec();
+    }
+    async loadLiveState(now) {
+        return createLiveState(await this.listInstances(now));
+    }
+    async loadRequestStats() {
+        const [globalRaw, errorCodeRaw, appRequestTypesRaw, providerRequestTypesRaw] = await Promise.all([
+            this.redis.hgetall(GLOBAL_STATS_KEY),
+            this.redis.hgetall(ERROR_CODE_COUNTS_KEY),
+            this.redis.hgetall(requestTypeCountsKey("app")),
+            this.redis.hgetall(requestTypeCountsKey("provider")),
+        ]);
+        return {
+            appRequests: parseInteger(globalRaw.appRequests),
+            providerRequests: parseInteger(globalRaw.providerRequests),
+            appSuccesses: parseInteger(globalRaw.appSuccesses),
+            providerSuccesses: parseInteger(globalRaw.providerSuccesses),
+            appErrors: parseInteger(globalRaw.appErrors),
+            providerErrors: parseInteger(globalRaw.providerErrors),
+            appFrames: parseInteger(globalRaw.appFrames),
+            providerFrames: parseInteger(globalRaw.providerFrames),
+            errorCodes: decodeErrorCodeCounts(errorCodeRaw),
+            requestTypes: [
+                ...decodeRequestTypeCounts("app", appRequestTypesRaw),
+                ...decodeRequestTypeCounts("provider", providerRequestTypesRaw),
+            ],
+        };
+    }
+    async recordSessionCreated(session, recordedAt) {
+        await this.ensureSession(session, recordedAt);
+    }
+    async recordSessionRenewed(session, recordedAt) {
+        await this.ensureSession(session, recordedAt);
+    }
+    async recordSessionClosed(sessionId, reason, recordedAt) {
+        await this.redis.hset(sessionKey(sessionId), {
+            updatedAt: String(recordedAt),
+            closedAt: String(recordedAt),
+            closeReason: reason,
+        });
+    }
+    async recordAppAttached(session, appId, recordedAt) {
+        await this.ensureSession(session, recordedAt);
+        const participantKey = sessionParticipantKey(session.sessionId, appId);
+        const participant = await this.loadParticipant(session.sessionId, appId);
+        const isNewParticipant = (await this.redis.sadd(sessionParticipantsKey(session.sessionId), appId)) === 1;
+        const pipeline = this.redis.multi();
+        pipeline.hset(participantKey, {
+            appId,
+            firstSeenAt: participant?.firstSeenAt !== undefined
+                ? String(participant.firstSeenAt)
+                : String(recordedAt),
+            lastSeenAt: String(recordedAt),
+            connectionCount: typeof participant?.lastConnectedAt === "number" &&
+                (typeof participant.lastDisconnectedAt !== "number" ||
+                    participant.lastDisconnectedAt < participant.lastConnectedAt)
+                ? String(participant.connectionCount)
+                : String((participant?.connectionCount ?? 0) + 1),
+            lastConnectedAt: typeof participant?.lastConnectedAt === "number" &&
+                (typeof participant.lastDisconnectedAt !== "number" ||
+                    participant.lastDisconnectedAt < participant.lastConnectedAt)
+                ? String(participant.lastConnectedAt)
+                : String(recordedAt),
+            totalConnectedMs: String(participant?.totalConnectedMs ?? 0),
+            messageCount: String(participant?.messageCount ?? 0),
+            ...(participant?.lastDisconnectedAt !== undefined
+                ? { lastDisconnectedAt: String(participant.lastDisconnectedAt) }
+                : {}),
+            ...(participant?.lastDisconnectReason
+                ? { lastDisconnectReason: participant.lastDisconnectReason }
+                : {}),
+        });
+        pipeline.hset(sessionKey(session.sessionId), { updatedAt: String(recordedAt) });
+        if (isNewParticipant) {
+            pipeline.hincrby(sessionKey(session.sessionId), "distinctParticipantCount", 1);
+        }
+        await pipeline.exec();
+    }
+    async recordAppDetached(sessionId, appId, recordedAt, reason) {
+        const participant = await this.loadParticipant(sessionId, appId);
+        if (!participant) {
+            return;
+        }
+        let totalConnectedMs = participant.totalConnectedMs;
+        if (typeof participant.lastConnectedAt === "number" &&
+            (typeof participant.lastDisconnectedAt !== "number" ||
+                participant.lastDisconnectedAt < participant.lastConnectedAt)) {
+            totalConnectedMs += Math.max(recordedAt - participant.lastConnectedAt, 0);
+        }
+        await this.redis
+            .multi()
+            .hset(sessionParticipantKey(sessionId, appId), {
+            lastSeenAt: String(recordedAt),
+            lastDisconnectedAt: String(recordedAt),
+            lastDisconnectReason: reason,
+            totalConnectedMs: String(totalConnectedMs),
+        })
+            .hset(sessionKey(sessionId), { updatedAt: String(recordedAt) })
+            .exec();
+    }
+    async recordAppFrame(sessionId, appId, recordedAt) {
+        await this.redis
+            .multi()
+            .hincrby(sessionKey(sessionId), "appMessageCount", 1)
+            .hset(sessionKey(sessionId), {
+            updatedAt: String(recordedAt),
+            lastAppMessageAt: String(recordedAt),
+        })
+            .hincrby(sessionParticipantKey(sessionId, appId), "messageCount", 1)
+            .hset(sessionParticipantKey(sessionId, appId), {
+            appId,
+            lastSeenAt: String(recordedAt),
+        })
+            .hincrby(GLOBAL_STATS_KEY, "appFrames", 1)
+            .exec();
+    }
+    async recordProviderFrame(sessionId, recordedAt) {
+        await this.redis
+            .multi()
+            .hincrby(sessionKey(sessionId), "providerMessageCount", 1)
+            .hset(sessionKey(sessionId), {
+            updatedAt: String(recordedAt),
+            lastProviderMessageAt: String(recordedAt),
+        })
+            .hincrby(GLOBAL_STATS_KEY, "providerFrames", 1)
+            .exec();
+    }
+    async recordRequest(params) {
+        const pipeline = this.redis.multi();
+        pipeline.hincrby(GLOBAL_STATS_KEY, params.actor === "app" ? "appRequests" : "providerRequests", 1);
+        pipeline.hincrby(GLOBAL_STATS_KEY, params.actor === "app"
+            ? params.ok
+                ? "appSuccesses"
+                : "appErrors"
+            : params.ok
+                ? "providerSuccesses"
+                : "providerErrors", 1);
+        pipeline.hincrby(requestTypeCountsKey(params.actor), `${params.type}:${params.ok ? "ok" : "error"}`, 1);
+        if (!params.ok && params.errorCode) {
+            pipeline.hincrby(ERROR_CODE_COUNTS_KEY, params.errorCode, 1);
+        }
+        await pipeline.exec();
+    }
+    async recordInstanceHeartbeat(heartbeat) {
+        const key = instanceKey(heartbeat.instanceId);
+        const providerIds = dedupeStrings(heartbeat.snapshot.providerIds);
+        const sessionIds = dedupeStrings(heartbeat.snapshot.sessionIds);
+        const participantBindings = dedupeBindings(heartbeat.snapshot.participantBindings);
+        const pipeline = this.redis.multi();
+        pipeline.hset(key, {
+            instanceId: heartbeat.instanceId,
+            startedAt: String(heartbeat.startedAt),
+            lastSeenAt: String(heartbeat.recordedAt),
+            activeProviders: String(heartbeat.snapshot.activeProviders),
+            activeApps: String(heartbeat.snapshot.activeApps),
+            localSessions: String(heartbeat.snapshot.localSessions),
+            providerIdsJson: JSON.stringify(providerIds),
+            sessionIdsJson: JSON.stringify(sessionIds),
+            participantBindingsJson: JSON.stringify(participantBindings),
+            memoryUsageJson: JSON.stringify(toSerializableMemoryUsage(heartbeat.snapshot.memoryUsage)),
+        });
+        pipeline.zadd(INSTANCE_INDEX_KEY, String(heartbeat.recordedAt), heartbeat.instanceId);
+        pipeline.pexpire(key, INSTANCE_TTL_MS * 2);
+        for (const binding of participantBindings) {
+            pipeline.hset(sessionParticipantKey(binding.sessionId, binding.appId), {
+                appId: binding.appId,
+                lastSeenAt: String(heartbeat.recordedAt),
+            });
+        }
+        await pipeline.exec();
+    }
+    async unregisterInstance(instanceId) {
+        await this.redis.multi().zrem(INSTANCE_INDEX_KEY, instanceId).del(instanceKey(instanceId)).exec();
+    }
+    async listSessions(options = {}) {
+        const now = options.now ?? Date.now();
+        await this.pruneStaleInstances(now);
+        const sessionIds = await this.redis.zrevrange(SESSION_INDEX_KEY, 0, -1);
+        const page = normalizePage(options.page);
+        const pageSize = normalizePageSize(options.pageSize);
+        if (sessionIds.length === 0) {
+            return {
+                total: 0,
+                page,
+                pageSize,
+                sessions: [],
+            };
+        }
+        const pipeline = this.redis.multi();
+        for (const sessionId of sessionIds) {
+            pipeline.hgetall(sessionKey(sessionId));
+        }
+        const results = await pipeline.exec();
+        const liveState = await this.loadLiveState(now);
+        const sessions = sessionIds
+            .map((sessionId, index) => decodeSessionHash(sessionId, results?.[index]?.[1] ?? {}))
+            .filter((session) => !!session)
+            .map((session) => toSessionSummary({ session, liveState, now }))
+            .filter((session) => options.status && options.status !== "all"
+            ? session.status === options.status
+            : true)
+            .filter((session) => matchesSessionQuery(session, options.query));
+        const startIndex = (page - 1) * pageSize;
+        return {
+            total: sessions.length,
+            page,
+            pageSize,
+            sessions: sessions.slice(startIndex, startIndex + pageSize),
+        };
+    }
+    async getSessionDetail(sessionId, now = Date.now()) {
+        await this.pruneStaleInstances(now);
+        const session = await this.loadSession(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        const participantIds = await this.redis.smembers(sessionParticipantsKey(sessionId));
+        const pipeline = this.redis.multi();
+        for (const appId of participantIds) {
+            pipeline.hgetall(sessionParticipantKey(sessionId, appId));
+        }
+        const participantHashes = await pipeline.exec();
+        const liveState = await this.loadLiveState(now);
+        const participants = participantIds
+            .map((appId, index) => decodeParticipantHash(appId, participantHashes?.[index]?.[1] ?? {}))
+            .filter((participant) => !!participant)
+            .map((participant) => toParticipantSummary({ sessionId, participant, liveState, now }))
+            .sort(sortParticipants);
+        return {
+            session: toSessionSummary({ session, liveState, now }),
+            participants,
+        };
+    }
+    async getOverview(now = Date.now()) {
+        await this.pruneStaleInstances(now);
+        const [sessionIds, instances, requestStats] = await Promise.all([
+            this.redis.zrevrange(SESSION_INDEX_KEY, 0, -1),
+            this.listInstances(now),
+            this.loadRequestStats(),
+        ]);
+        let sessions = [];
+        if (sessionIds.length > 0) {
+            const pipeline = this.redis.multi();
+            for (const sessionId of sessionIds) {
+                pipeline.hgetall(sessionKey(sessionId));
+            }
+            const results = await pipeline.exec();
+            const liveState = createLiveState(instances);
+            sessions = sessionIds
+                .map((sessionId, index) => decodeSessionHash(sessionId, results?.[index]?.[1] ?? {}))
+                .filter((session) => !!session)
+                .map((session) => toSessionSummary({ session, liveState, now }));
+        }
+        return this.buildOverview({
+            sessions,
+            instances,
+            requestStats,
+            generatedAt: now,
+        });
+    }
+    async listInstances(now = Date.now()) {
+        await this.pruneStaleInstances(now);
+        const instanceIds = await this.redis.zrevrange(INSTANCE_INDEX_KEY, 0, -1);
+        if (instanceIds.length === 0) {
+            return [];
+        }
+        const pipeline = this.redis.multi();
+        for (const instanceId of instanceIds) {
+            pipeline.hgetall(instanceKey(instanceId));
+        }
+        const results = await pipeline.exec();
+        return instanceIds
+            .map((instanceId, index) => decodeInstanceHash(instanceId, results?.[index]?.[1] ?? {}))
+            .filter((instance) => !!instance)
+            .sort((left, right) => right.lastSeenAt - left.lastSeenAt || left.instanceId.localeCompare(right.instanceId));
+    }
+    async close() {
+        await this.redis.quit();
+    }
+}
+export function createRelayAdminMetricsStore(params) {
+    if (params.redisUrl) {
+        return new RedisRelayAdminMetricsStore(params.redisUrl);
+    }
+    return new InMemoryRelayAdminMetricsStore();
+}
+//# sourceMappingURL=admin-metrics-store.js.map