import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from "react"; import type { CSSProperties } from "react"; import { Funnel, X } from "@phosphor-icons/react"; import { createPortal } from "react-dom"; import { AiUsageCard } from "../account/UsagePage"; import { loadUsage } from "../account/accountApi"; import type { Usage } from "../account/accountApi"; import { UNAUTHORIZED_EVENT } from "../apiContract"; import { useOverlayLayer } from "../customer-grid/OverlaySurface"; import { Popover } from "../filter-kit"; import { isAdmin } from "../shell/session"; import type { SessionUser } from "../shell/session"; import { getUsageActivity, getUsageMcpActivity, listUsers, USAGE_KIND_LABELS } from "./settingsApi"; import type { UsageActivity, UsageActivityFilters, UsageKind, UsageMcpActivity, UsageMcpEvent, UsageSource } from "./settingsApi"; import "../styles/sdlc85/settings-usage.css"; const count = (value: number | null | undefined) => value == null ? "Unavailable" : value.toLocaleString(); const plain = (value: string) => value.replace(/[\u2013\u2014]/g, " "); const words = (value: string) => value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").toLowerCase(); const sourceNames: Record = { security_events: "Security events", activity_events: "Activity events", value_history: "Cell history", view_audit: "View history", turn_audit: "AI turns", }; function usageDates(now = new Date()) { const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())); const first = new Date(today); first.setUTCDate(first.getUTCDate() - 29); const earliest = new Date(Date.UTC(today.getUTCFullYear(), today.getUTCMonth() - 13, 1)); const lastDay = new Date(Date.UTC(earliest.getUTCFullYear(), earliest.getUTCMonth() + 1, 0)).getUTCDate(); earliest.setUTCDate(Math.min(today.getUTCDate(), lastDay)); return { from: first.toISOString().slice(0, 10), to: today.toISOString().slice(0, 10), min: earliest.toISOString().slice(0, 10) }; } function Skeleton({ label = "Loading usage" }: { label?: string }) { return
{[0, 1, 2].map(row =>
; } function ReadError({ onRetry, reload = false }: { onRetry: () => void; reload?: boolean }) { return
{reload ? "Reload MCP activity to continue." : "Usage could not be loaded."}
; } function Sources({ sources, onRetry }: { sources: UsageSource[]; onRetry: () => void }) { const limitLabels = new Map([ ["retention", "Retention limit"], ["legacy_ring", "Legacy event limit"], ["view_ring", "Stored view limit"], ["turn_week_cap", "Weekly AI limit"], ]); return

Sources

{sources.map(source => )}
SourceHeld fromRetentionLimits
{sourceNames[source.source] || plain(words(source.source))} {source.kinds.map(kind => USAGE_KIND_LABELS[kind]).join(", ")} {source.status === "error" ? "Unreadable" : source.status === "partial" ? "Partial" : "Available"} {count(source.total)} events {source.retention ? Object.entries(source.retention).map(([key, value]) =>
{words(key)}: {value === null ? "Not time limited" : count(value)}
) : "Unavailable"}
{source.error ?
Source unavailable {plain(words(source.error.code))}
: null} {source.limitations.length ? source.limitations.map((limit, index) =>
{limitLabels.get(limit.code) || "Source limit"} {limit.week ? Week {limit.week} : null} {limit.heldFrom ? Held from {plain(limit.heldFrom)} : null} {limit.lost != null ? Lost: {count(limit.lost)} : null} {limit.limit != null ? Limit: {count(limit.limit)} : null}
) : source.error ? null : "None"}
; } function EventDetail({ event, onClose }: { event: UsageMcpEvent; onClose: () => void }) { const panelRef = useRef(null); const titleId = useId(); useOverlayLayer({ panelRef, onDismiss: onClose, dismissOnOutside: false, trapFocus: true }); const fields: Array<[string, string]> = [ ["Tool", event.tool], ["Action", event.action], ["Outcome", event.outcome], ["Code", event.code], ["Time", event.time], ["User", event.user], ["Database", event.database], ["Key ID", event.keyId], ["Key label", event.keyLabel], ]; return createPortal(

MCP event

{fields.map(([label, value]) =>
{label}
{plain(value) || "Unknown"}
)}
, document.body); } function McpReport({ filters, tenant }: { filters: UsageActivityFilters; tenant: string }) { const [report, setReport] = useState(null); const [events, setEvents] = useState([]); const [selectedId, setSelectedId] = useState(null); const [loading, setLoading] = useState(true); const [failed, setFailed] = useState(false); const [needsReload, setNeedsReload] = useState(false); const [revision, setRevision] = useState(0); const request = useRef(null); const read = useCallback(async (cursor?: string) => { request.current?.abort(); const controller = new AbortController(); request.current = controller; setLoading(true); setFailed(false); const result = await getUsageMcpActivity(filters, controller.signal, cursor); if (controller.signal.aborted) return; setLoading(false); if (!result.ok) { const invalidCursor = (result.status === 400 && result.code === "usage_mcp_cursor_invalid") || (result.status === 409 && result.code === "usage_mcp_cursor_stale"); setNeedsReload(invalidCursor); setFailed(true); setSelectedId(null); if (invalidCursor || result.status === 401 || result.status === 403) { setReport(null); setEvents([]); } return; } if (result.data.tenant !== tenant) { setFailed(true); setReport(null); setEvents([]); return; } setNeedsReload(false); setReport(result.data); setEvents(old => cursor ? [...old, ...result.data.events] : result.data.events); }, [filters, tenant]); useEffect(() => { setReport(null); setEvents([]); setSelectedId(null); setNeedsReload(false); void read(); return () => request.current?.abort(); }, [read, revision]); const reload = () => { setSelectedId(null); setRevision(value => value + 1); }; const selected = events.find(event => event.id === selectedId); return

MCP activity

{failed ? { void read(report?.nextCursor || undefined); }} /> : null} {loading && !report ? : null} {report ? <>

{count(report.total)} calls{report.complete ? "" : " retained"}

{report.byTool.map(row => )}
ToolCallsOutcomes
{plain(row.tool)}{count(row.total)} {Object.entries(row.byOutcome).map(([outcome, total]) => {plain(outcome)}: {count(total)})}
{report.total === 0 ?

No MCP activity in this range

: null} {events.length ?
{events.map(event => setSelectedId(event.id)}> )}
ToolOutcomeUserTime
{plain(event.outcome)}{plain(event.user) || "Unknown"}
: null}
{count(events.length)} of {count(report.total)} calls shown {report.nextCursor && !failed ? : null}
{loading && report ? : null} : null} {selected ? setSelectedId(null)} /> : null}
; } const activityColors: Record = { mcp: "var(--lp-freeze-navy)", api: "var(--lp-freeze-gold)", sign_in: "var(--lp-green-deep)", record_edit: "var(--lp-purple-deep)", field_edit: "var(--lp-teal-deep)", cell_edit: "var(--lp-orange-deep)", view_edit: "var(--lp-pink-deep)", ai_turn: "var(--lp-red-deep)", }; /** The narrowest readable day column, in px, before the Daily activity chart scrolls. */ const MIN_DAY_WIDTH = 12; function DailyActivityChart({ report, kinds }: { report: UsageActivity; kinds: UsageKind[] }) { const [hiddenKinds, setHiddenKinds] = useState([]); const [focusedDay, setFocusedDay] = useState(0); const [hoveredDay, setHoveredDay] = useState(null); const chartRef = useRef(null); const scrollRef = useRef(null); const [boxWidth, setBoxWidth] = useState(0); const titleId = useId(); const descriptionId = useId(); const known = (value: number | null | undefined) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null; // A kind with no range total cannot be read, so its rail row is disabled and it never joins the chart. const readable = kinds.filter(kind => known(report.byKind[kind]) !== null); const enabled = readable.filter(kind => !hiddenKinds.includes(kind)); const days = report.byDay.map(row => { const values = enabled.map(kind => ({ kind, value: known(row.byKind[kind]) })); return { day: row.day, values, knownTotal: values.reduce((total, item) => item.value === null ? total : total + item.value, 0), anyKnown: values.some(item => item.value !== null) }; }); const retained = !report.complete; const valueLabel = (value: number | null) => value === null ? "Unavailable" : `${count(value)}${retained ? " retained" : ""}`; const dayLabel = (day: string, short = false) => new Date(`${day}T00:00:00Z`).toLocaleDateString(undefined, short ? { month: "short", day: "numeric", timeZone: "UTC" } : { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" }); const describeDay = (row: typeof days[number]) => `${dayLabel(row.day)}. ${row.values .map(item => `${USAGE_KIND_LABELS[item.kind]}: ${valueLabel(item.value)}`).join(". ")}`; const maximum = days.reduce((max, row) => Math.max(max, row.knownTotal), 0); const step = Math.max(1, Math.ceil(maximum / 4)); const ceiling = step * 4; const left = Math.max(48, count(ceiling).length * 8 + 12); const plotted = enabled.length > 0 && days.length > 0; // The plot fills its scroll box. It scrolls only when a day would fall under the readable minimum. useLayoutEffect(() => { const box = scrollRef.current; if (!box) return; const measure = () => setBoxWidth(Math.floor(box.getBoundingClientRect().width)); measure(); if (typeof ResizeObserver === "undefined") return; const observer = new ResizeObserver(measure); observer.observe(box); return () => observer.disconnect(); }, [plotted]); const width = Math.max(left + days.length * MIN_DAY_WIDTH + 16, boxWidth || 600); const top = 32; const plotHeight = 176; const bottom = top + plotHeight; const slot = (width - left - 16) / Math.max(days.length, 1); const labelEvery = Math.max(7, Math.ceil(days.length / 12)); const inspected = days[hoveredDay ?? focusedDay]; const unavailable = kinds.filter(kind => !readable.includes(kind) || (enabled.includes(kind) && report.byDay.some(row => known(row.byKind[kind]) === null))); const unavailableNames = unavailable.map(kind => USAGE_KIND_LABELS[kind]); const unavailableNote = unavailableNames.length ? `${unavailableNames.length > 1 ? `${unavailableNames.slice(0, -1).join(", ")} and ${unavailableNames[unavailableNames.length - 1]}` : unavailableNames[0]} unavailable` : ""; const toggle = (kind: UsageKind) => setHiddenKinds(old => old.includes(kind) ? old.filter(item => item !== kind) : [...old, kind]); return

Daily activity

Metrics {kinds.map(kind => { const total = known(report.byKind[kind]); const on = total !== null && !hiddenKinds.includes(kind); return ; })}

{report.from} to {report.to} ({report.timezone}){retained ? " · Retained counts" : ""}

{!enabled.length ?

{readable.length ? "Select a metric" : "Daily counts unavailable"}

: !days.length ?

Daily counts unavailable

: <>
Stacked daily event counts for the enabled metrics. Use the arrow keys to browse days, or open Daily values. {retained ? " Counts cover retained activity only." : ""} {unavailableNote ? ` ${unavailableNote}. Unavailable counts have no segment.` : ""} {days.map((row, index) => { const x = left + index * slot; let stacked = 0; return setHoveredDay(index)} onPointerLeave={() => setHoveredDay(null)} onFocus={() => { setHoveredDay(null); setFocusedDay(index); }} onKeyDown={event => { const next = event.key === "ArrowRight" ? Math.min(days.length - 1, index + 1) : event.key === "ArrowLeft" ? Math.max(0, index - 1) : event.key === "Home" ? 0 : event.key === "End" ? days.length - 1 : null; if (next === null) return; event.preventDefault(); const target = chartRef.current?.querySelector(`[data-day-index="${next}"]`); target?.focus(); target?.scrollIntoView({ block: "nearest", inline: "nearest", behavior: "instant" }); }}> {describeDay(row)} {row.values.map(({ kind, value }) => { if (value === null || value === 0) return null; stacked += value; return ; })} {row.anyKnown && row.knownTotal === 0 ? : null} {(index === 0 || index === days.length - 1 || (index % labelEvery === 0 && index < days.length - 3)) ? : null} ; })}
{unavailableNote ?

{unavailableNote}

: null} {inspected ?
{inspected.values.map(({ kind, value }) =>
{valueLabel(value)}
)}
: null}
Daily values
{enabled.map(kind => )}{days.map(row => {row.values.map(({ kind, value }) => )} )}
Date{USAGE_KIND_LABELS[kind]}
{valueLabel(value)}
}
; } function ActivityReport({ filters, tenant, onUsers }: { filters: UsageActivityFilters; tenant: string; onUsers: (users: string[]) => void; }) { const [report, setReport] = useState(null); const [failed, setFailed] = useState(false); const [revision, setRevision] = useState(0); useEffect(() => { const controller = new AbortController(); setReport(null); setFailed(false); void getUsageActivity(filters, controller.signal).then(result => { if (controller.signal.aborted) return; if (!result.ok || result.data.tenant !== tenant) { setFailed(true); return; } setReport(result.data); onUsers(result.data.byUser.map(row => row.user)); }); return () => controller.abort(); }, [filters, tenant, onUsers, revision]); const retry = () => setRevision(value => value + 1); if (failed) return ; if (!report) return ; const kinds = Object.keys(report.byKind) as UsageKind[]; const rangeFoot = report.complete ? "Selected range" : "Retained range"; // A null total means one source failed. The sum of the kinds that were read still shows, labelled as partial. const partialTotal = report.total == null && typeof report.availableTotal === "number"; const metrics: Array<[string, number | null | undefined, string]> = [ ["Total", partialTotal ? report.availableTotal : report.total, partialTotal ? "Excludes unavailable metrics" : rangeFoot], ...kinds.map(kind => [USAGE_KIND_LABELS[kind], report.byKind[kind], rangeFoot] as [string, number | null | undefined, string]), ]; const period = `${report.from} to ${report.to}`; return <>
{metrics.map(([label, value, foot]) =>
{label}
{count(value)}
{foot}
)}

By user

{kinds.map(kind => )}{report.byUser.map(row => {kinds.map(kind => )} )}
User{USAGE_KIND_LABELS[kind]}
{plain(row.user) || "Unknown"}{count(row.byKind[kind])}
{!report.byUser.length ?

{report.complete ? "No activity in this range" : "No retained activity in this range"}

: null}

{period} ({report.timezone})

{filters.kind === "mcp" ? : null} ; } function AiAllowance() { const [usage, setUsage] = useState(null); const [failed, setFailed] = useState(false); const [revision, setRevision] = useState(0); useEffect(() => { let live = true; setUsage(null); setFailed(false); void loadUsage("tenant").then(result => { if (!live) return; if (result.ok) setUsage(result.value); else setFailed(true); }); return () => { live = false; }; }, [revision]); return

AI usage

{failed ? setRevision(value => value + 1)} /> : usage ? : }
; } function AdminUsagePane({ user }: { user: SessionUser }) { const [dates] = useState(() => usageDates()); const [filters, setFilters] = useState({ from: dates.from, to: dates.to, user: "", kind: "" }); const [users, setUsers] = useState([]); const [expired, setExpired] = useState(false); const [revision, setRevision] = useState(0); const addUsers = useCallback((names: string[]) => setUsers(old => [...new Set([...old, ...names])].sort()), []); useEffect(() => { let live = true; void listUsers().then(result => { if (live && result.ok) addUsers(result.data.users.map(row => row.username)); }); const expire = () => setExpired(true); window.addEventListener(UNAUTHORIZED_EVENT, expire); return () => { live = false; window.removeEventListener(UNAUTHORIZED_EVENT, expire); }; }, [addUsers]); const filterCount = Number(Boolean(filters.user)) + Number(Boolean(filters.kind)); const validRange = filters.from >= dates.min && filters.to <= dates.to && filters.from <= filters.to; const update = (patch: Partial) => setFilters(old => ({ ...old, ...patch })); const key = JSON.stringify([filters, revision]); return

Usage

{expired ?

Reopen Settings to view usage.

: <>
{filterCount ?

{[filters.user ? `User: ${plain(filters.user)}` : "", filters.kind ? `Kind: ${USAGE_KIND_LABELS[filters.kind]}` : ""].filter(Boolean).join(" · ")}

: null} {!validRange ?

Choose dates within the last 13 months.

: } }
; } export default function UsagePane({ user }: { user: SessionUser }) { return isAdmin(user) ? : null; }