@wopr-network/platform-ui-core 1.0.0

package/src/lib/admin-api.ts

@@ -0,0 +1,325 @@
+import { trpcVanilla } from "./trpc";
+
+// ---- Types ----
+
+export interface AdminUserSummary {
+  id: string;
+  email: string;
+  name: string | null;
+  tenant_id: string;
+  status: string;
+  role: string;
+  credit_balance_cents: number;
+  agent_count: number;
+  last_seen: number | null;
+  created_at: number;
+}
+
+export interface TenantDetailResponse {
+  user: AdminUserSummary | null;
+  credits: {
+    balance_cents: number;
+    recent_transactions: { entries: CreditAdjustment[]; total: number };
+  };
+  status: {
+    tenantId: string;
+    status: string;
+    statusReason?: string | null;
+    statusChangedAt?: number | null;
+    statusChangedBy?: string | null;
+    graceDeadline?: string | null;
+    dataDeleteAfter?: string | null;
+  };
+  usage: {
+    summaries: UsageSummary[];
+    total: { totalCost: number; totalCharge: number; eventCount: number };
+  };
+}
+
+export interface CreditAdjustment {
+  id: string;
+  tenant: string;
+  type: "grant" | "refund" | "correction";
+  amount_cents: number;
+  reason: string;
+  admin_user: string;
+  reference_ids: string | null;
+  created_at: number;
+}
+
+export interface UsageSummary {
+  tenant: string;
+  capability: string;
+  provider: string;
+  event_count: number;
+  total_cost: number;
+  total_charge: number;
+  total_duration: number;
+  window_start: number;
+  window_end: number;
+}
+
+export interface AdminNote {
+  id: string;
+  tenant_id: string;
+  admin_user: string;
+  content: string;
+  created_at: number;
+}
+
+export interface BotInstance {
+  id: string;
+  tenantId: string;
+  name: string;
+  nodeId: string | null;
+  billingState: string;
+  suspendedAt: string | null;
+  destroyAfter: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// ---- API calls ----
+
+export async function getTenantDetail(tenantId: string): Promise<TenantDetailResponse> {
+  return trpcVanilla.admin.tenantDetail.query({ tenantId });
+}
+
+export async function getTenantAgents(tenantId: string): Promise<BotInstance[]> {
+  const result = await trpcVanilla.admin.tenantAgents.query({ tenantId });
+  return result.agents;
+}
+
+export async function getTenantNotes(tenantId: string): Promise<AdminNote[]> {
+  // Backend procedure is notesList, not tenantNotes
+  const result = await trpcVanilla.admin.notesList.query({ tenantId });
+  return result.notes;
+}
+
+export async function addTenantNote(tenantId: string, content: string): Promise<AdminNote> {
+  // Backend procedure is notesCreate, not tenantNoteAdd
+  return trpcVanilla.admin.notesCreate.mutate({ tenantId, content });
+}
+
+export async function suspendTenant(tenantId: string, reason: string): Promise<void> {
+  await trpcVanilla.admin.suspendTenant.mutate({ tenantId, reason });
+}
+
+export async function reactivateTenant(tenantId: string): Promise<void> {
+  await trpcVanilla.admin.reactivateTenant.mutate({ tenantId });
+}
+
+export async function grantCredits(
+  tenantId: string,
+  amount_cents: number,
+  reason: string,
+): Promise<void> {
+  await trpcVanilla.admin.creditsGrant.mutate({ tenantId, amount_cents, reason });
+}
+
+export async function refundCredits(
+  tenantId: string,
+  amount_cents: number,
+  reason: string,
+): Promise<void> {
+  await trpcVanilla.admin.creditsRefund.mutate({ tenantId, amount_cents, reason });
+}
+
+export async function changeRole(userId: string, tenantId: string, role: string): Promise<void> {
+  await trpcVanilla.admin.tenantChangeRole.mutate({ userId, tenantId, role });
+}
+
+export async function banTenant(
+  tenantId: string,
+  reason: string,
+  tosReference: string,
+  confirmName: string,
+): Promise<void> {
+  await trpcVanilla.admin.banTenant.mutate({ tenantId, reason, tosReference, confirmName });
+}
+
+export async function getTransactionsCsv(tenantId: string): Promise<string> {
+  const result = await trpcVanilla.admin.creditsTransactionsExport.query({ tenantId });
+  return result.csv;
+}
+
+export async function getTransactions(
+  tenantId: string,
+  filters?: {
+    type?: string;
+    from?: number;
+    to?: number;
+    limit?: number;
+    offset?: number;
+  },
+): Promise<{ entries: CreditAdjustment[]; total: number }> {
+  return trpcVanilla.admin.creditsTransactions.query({ tenantId, ...filters });
+}
+
+export async function getTenantUsageByCapability(
+  tenantId: string,
+  days = 30,
+): Promise<UsageSummary[]> {
+  const result = await trpcVanilla.admin.tenantUsageByCapability.query({ tenantId, days });
+  return result.usage;
+}
+
+export async function getUsersList(params?: {
+  search?: string;
+  limit?: number;
+  offset?: number;
+}): Promise<{ users: AdminUserSummary[]; total: number }> {
+  return trpcVanilla.admin.usersList.query(params ?? {});
+}
+
+export async function bulkGrantCredits(
+  tenantIds: string[],
+  amountCents: number,
+  reason: string,
+): Promise<void> {
+  await trpcVanilla.admin.bulkGrant.mutate({ tenantIds, amountCents, reason });
+}
+
+export async function bulkSuspendTenants(tenantIds: string[], reason: string): Promise<void> {
+  await trpcVanilla.admin.bulkSuspend.mutate({ tenantIds, reason });
+}
+
+export async function bulkReactivateTenants(tenantIds: string[]): Promise<void> {
+  await trpcVanilla.admin.bulkReactivate.mutate({ tenantIds });
+}
+
+// ---- Onboarding ----
+
+export interface OnboardingFunnelStep {
+  step: string;
+  label: string;
+  started: number;
+  completed: number;
+  dropped: number;
+  completion_rate: number;
+  avg_duration_ms: number | null;
+}
+
+export interface OnboardingFunnelStats {
+  steps: OnboardingFunnelStep[];
+  total_started: number;
+  total_completed: number;
+  overall_completion_rate: number;
+  time_to_first_bot_ms: number | null;
+}
+
+export interface OnboardingScript {
+  id: string;
+  name: string;
+  content: string;
+  version: number;
+  active: boolean;
+  created_at: number;
+  updated_at: number;
+}
+
+export async function getOnboardingFunnelStats(days = 30): Promise<OnboardingFunnelStats> {
+  return trpcVanilla.admin.onboardingFunnelStats.query({ days });
+}
+
+export async function getOnboardingScripts(): Promise<OnboardingScript[]> {
+  const result = await trpcVanilla.admin.onboardingScriptList.query({});
+  return result.scripts;
+}
+
+export async function saveOnboardingScript(
+  id: string | null,
+  name: string,
+  content: string,
+): Promise<OnboardingScript> {
+  return trpcVanilla.admin.onboardingScriptSave.mutate({ id, name, content });
+}
+
+// ---- Roles ----
+
+export interface AdminRole {
+  id: string;
+  name: string;
+  description: string | null;
+  is_system: boolean;
+  created_at: number;
+}
+
+export interface UserRoleAssignment {
+  user_id: string;
+  tenant_id: string;
+  email: string;
+  name: string | null;
+  role: string;
+  assigned_at: number | null;
+  assigned_by: string | null;
+}
+
+export async function getRolesList(): Promise<{
+  roles: AdminRole[];
+  assignments: UserRoleAssignment[];
+}> {
+  return trpcVanilla.admin.rolesList.query({});
+}
+
+export async function assignRole(userId: string, tenantId: string, role: string): Promise<void> {
+  await trpcVanilla.admin.rolesAssign.mutate({ userId, tenantId, role });
+}
+
+export async function revokeRole(userId: string, tenantId: string, role: string): Promise<void> {
+  await trpcVanilla.admin.rolesRevoke.mutate({ userId, tenantId, role });
+}
+
+// ---- Migrations ----
+
+export interface MigrationRecord {
+  id: string;
+  name: string;
+  status: "pending" | "running" | "completed" | "failed";
+  applied_at: number | null;
+  duration_ms: number | null;
+  error: string | null;
+}
+
+export interface MigrationSnapshot {
+  id: string;
+  tenant_id: string;
+  name: string;
+  size_bytes: number;
+  created_at: number;
+}
+
+export interface MigrationRestoreRecord {
+  id: string;
+  tenant_id: string;
+  snapshot_id: string;
+  snapshot_name: string;
+  restored_by: string;
+  restored_at: number;
+  status: "pending" | "completed" | "failed";
+  error: string | null;
+}
+
+export async function getMigrations(): Promise<MigrationRecord[]> {
+  const result = await trpcVanilla.admin.migrationList.query({});
+  return result.migrations;
+}
+
+export async function getMigrationSnapshots(tenantId: string): Promise<MigrationSnapshot[]> {
+  const result = await trpcVanilla.admin.migrationSnapshotList.query({ tenantId });
+  return result.snapshots;
+}
+
+export async function restoreMigrationSnapshot(
+  tenantId: string,
+  snapshotId: string,
+): Promise<void> {
+  await trpcVanilla.admin.migrationRestore.mutate({ tenantId, snapshotId });
+}
+
+export async function getMigrationRestoreHistory(
+  tenantId: string,
+): Promise<MigrationRestoreRecord[]> {
+  const result = await trpcVanilla.admin.migrationRestoreHistory.query({ tenantId });
+  return result.history;
+}

package/src/lib/admin-compliance-api.ts

@@ -0,0 +1,127 @@
+import { apiFetch } from "./api";
+import { trpcVanilla } from "./trpc";
+
+// --- Types ---
+
+export interface DeletionRequest {
+  id: string;
+  tenantId: string;
+  requestedBy: string;
+  status: string;
+  deleteAfter: string;
+  cancelReason: string | null;
+  completedAt: string | null;
+  deletionSummary: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ExportRequest {
+  id: string;
+  tenantId: string;
+  requestedBy: string;
+  status: string;
+  format: string;
+  downloadUrl: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface EvidenceReport {
+  generatedAt: string;
+  period: { from: string; to: string };
+  sections: {
+    accessLogging: {
+      totalEntries: number;
+      oldestEntry: string | null;
+      newestEntry: string | null;
+      actionBreakdown: Record<string, number>;
+      retentionDays: number;
+    };
+    backupRecovery: {
+      totalContainers: number;
+      containersWithRecentBackup: number;
+      staleContainers: number;
+      lastVerificationReport: string | null;
+    };
+    encryption: {
+      algorithm: string;
+      keyDerivation: string;
+      tlsEnforced: boolean;
+    };
+    mfaEnforcement: {
+      pluginEnabled: boolean;
+      tenantsWithMfaMandate: number;
+      totalTenants: number;
+    };
+    accessReview: {
+      adminActions: number;
+      adminActionBreakdown: Record<string, number>;
+    };
+  };
+}
+
+export interface RetentionPolicy {
+  dataType: string;
+  retentionDays: number;
+  autoDelete: boolean;
+  lastPurge: string | null;
+  recordsAffected: number;
+}
+
+// --- API calls ---
+
+export async function fetchComplianceEvidence(from: string, to: string): Promise<EvidenceReport> {
+  return apiFetch<EvidenceReport>(
+    `/admin/compliance/evidence?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`,
+  );
+}
+
+export async function fetchRetentionPolicies(): Promise<RetentionPolicy[]> {
+  return apiFetch<RetentionPolicy[]>("/admin/compliance/retention");
+}
+
+export async function getDeletionRequests(filters?: {
+  status?: string;
+  limit?: number;
+  offset?: number;
+}): Promise<{ requests: DeletionRequest[]; total: number }> {
+  return trpcVanilla.admin.complianceDeletionRequests.query(filters ?? {});
+}
+
+export async function triggerDeletion(tenantId: string, reason: string): Promise<DeletionRequest> {
+  return trpcVanilla.admin.complianceTriggerDeletion.mutate({
+    tenantId,
+    reason,
+  });
+}
+
+export async function getExportRequests(filters?: {
+  status?: string;
+  limit?: number;
+  offset?: number;
+}): Promise<{ requests: ExportRequest[]; total: number }> {
+  return trpcVanilla.admin.complianceExportRequests.query(filters ?? {});
+}
+
+export async function triggerExport(tenantId: string, reason: string): Promise<ExportRequest> {
+  return trpcVanilla.admin.complianceTriggerExport.mutate({
+    tenantId,
+    reason,
+  });
+}
+
+export async function cancelDeletion(requestId: string): Promise<DeletionRequest> {
+  return trpcVanilla.admin.complianceCancelDeletion.mutate({ requestId });
+}
+
+export async function updateRetentionPolicy(
+  dataType: string,
+  updates: { retentionDays?: number; autoDelete?: boolean },
+): Promise<RetentionPolicy> {
+  return apiFetch<RetentionPolicy>(`/admin/compliance/retention/${encodeURIComponent(dataType)}`, {
+    method: "PATCH",
+    body: JSON.stringify(updates),
+    headers: { "Content-Type": "application/json" },
+  });
+}

package/src/lib/admin-gpu-api.ts

@@ -0,0 +1,82 @@
+import { apiFetch, apiFetchRaw } from "./api";
+
+// ---- Types ----
+
+export type GpuStatus = "running" | "stopped" | "provisioning" | "error" | "rebooting";
+
+export interface GpuNode {
+  id: string;
+  name: string;
+  region: string;
+  size: string;
+  status: GpuStatus;
+  ipAddress: string | null;
+  /** GPU utilization 0–100 */
+  utilization: number | null;
+  /** VRAM used in MiB */
+  memoryUsedMib: number | null;
+  /** Total VRAM in MiB */
+  memoryTotalMib: number | null;
+  /** Temperature in °C */
+  temperatureCelsius: number | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface GpuRegion {
+  slug: string;
+  name: string;
+  available: boolean;
+}
+
+export interface GpuSize {
+  slug: string;
+  name: string;
+  vcpus: number;
+  memoryMib: number;
+  gpuCount: number;
+  gpuModel: string;
+  /** Monthly price in USD (whole dollars, matching DigitalOcean convention) */
+  priceMonthly: number;
+}
+
+export interface ProvisionRequest {
+  name: string;
+  region: string;
+  size: string;
+}
+
+// ---- API calls ----
+
+export async function listGpuNodes(): Promise<GpuNode[]> {
+  return apiFetch<GpuNode[]>("/admin/gpu");
+}
+
+export async function getGpuNode(id: string): Promise<GpuNode> {
+  return apiFetch<GpuNode>(`/admin/gpu/${encodeURIComponent(id)}`);
+}
+
+export async function provisionGpuNode(req: ProvisionRequest): Promise<GpuNode> {
+  return apiFetch<GpuNode>("/admin/gpu", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(req),
+  });
+}
+
+export async function destroyGpuNode(id: string): Promise<void> {
+  const res = await apiFetchRaw(`/admin/gpu/${encodeURIComponent(id)}`, { method: "DELETE" });
+  if (!res.ok) throw new Error(await res.text());
+}
+
+export async function rebootGpuNode(id: string): Promise<GpuNode> {
+  return apiFetch<GpuNode>(`/admin/gpu/${encodeURIComponent(id)}/reboot`, { method: "POST" });
+}
+
+export async function listGpuRegions(): Promise<GpuRegion[]> {
+  return apiFetch<GpuRegion[]>("/admin/gpu/regions");
+}
+
+export async function listGpuSizes(): Promise<GpuSize[]> {
+  return apiFetch<GpuSize[]>("/admin/gpu/sizes");
+}

package/src/lib/admin-incident-api.ts

@@ -0,0 +1,121 @@
+import { apiFetch } from "./api";
+
+// --- Types ---
+
+export type IncidentSeverity = "SEV1" | "SEV2" | "SEV3";
+
+export interface SeveritySignals {
+  stripeReachable: boolean;
+  webhooksReceiving?: boolean | null;
+  gatewayErrorRate: number;
+  creditDeductionFailures: number;
+  dlqDepth: number;
+  tenantsWithNegativeBalance: number;
+  autoTopupFailures: number;
+  firingAlertCount: number;
+}
+
+export interface SeverityResult {
+  severity: IncidentSeverity;
+  label: string;
+  description: string;
+}
+
+export interface EscalationContact {
+  role: string;
+  name: string;
+  method: string;
+  within: string;
+}
+
+export interface EscalationResult {
+  severity: IncidentSeverity;
+  contacts: EscalationContact[];
+}
+
+export interface ResponseProcedure {
+  severity: IncidentSeverity;
+  steps: string[];
+}
+
+export interface CommunicateContext {
+  severity: IncidentSeverity;
+  incidentId: string;
+  startedAt: string;
+  affectedSystems: string[];
+  customerImpact: string;
+  currentStatus: string;
+}
+
+export interface CommunicationTemplates {
+  customer: string;
+  internal: string;
+}
+
+export interface PostmortemInput {
+  incidentId: string;
+  severity: IncidentSeverity;
+  title: string;
+  startedAt: string;
+  detectedAt: string;
+  resolvedAt: string | null;
+  affectedSystems: string[];
+  affectedTenantCount: number;
+  revenueImpactDollars: number | null;
+}
+
+// --- API calls ---
+
+export async function classifyIncidentSeverity(signals: SeveritySignals): Promise<SeverityResult> {
+  const result = await apiFetch<{ success: boolean; error?: string } & SeverityResult>(
+    "/admin/incidents/severity",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(signals),
+    },
+  );
+  if (!result.success) throw new Error(result.error ?? "Request failed");
+  return result;
+}
+
+export async function getEscalationMatrix(severity: IncidentSeverity): Promise<EscalationResult> {
+  return apiFetch<EscalationResult>(`/admin/incidents/escalation/${severity}`);
+}
+
+export async function getResponseProcedure(severity: IncidentSeverity): Promise<ResponseProcedure> {
+  const result = await apiFetch<{ success: boolean; procedure: ResponseProcedure; error?: string }>(
+    `/admin/incidents/procedure/${severity}`,
+  );
+  if (!result.success) throw new Error(result.error ?? "Request failed");
+  return result.procedure;
+}
+
+export async function getCommunicationTemplates(
+  context: CommunicateContext,
+): Promise<CommunicationTemplates> {
+  const result = await apiFetch<{
+    success: boolean;
+    templates: CommunicationTemplates;
+    error?: string;
+  }>("/admin/incidents/communicate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(context),
+  });
+  if (!result.success) throw new Error(result.error ?? "Request failed");
+  return result.templates;
+}
+
+export async function generatePostmortem(input: PostmortemInput): Promise<string> {
+  const result = await apiFetch<{ success: boolean; report: string; error?: string }>(
+    "/admin/incidents/postmortem",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+    },
+  );
+  if (!result.success) throw new Error(result.error ?? "Request failed");
+  return result.report;
+}

package/src/lib/admin-inference-api.ts

@@ -0,0 +1,47 @@
+import { trpcVanilla } from "./trpc";
+
+// ---- Types (mirror backend domain types until SDK is published) ----
+
+export interface DailyCostAggregate {
+  day: string; // YYYY-MM-DD
+  totalCostUsd: number;
+  sessionCount: number;
+}
+
+export interface PageCostAggregate {
+  page: string;
+  totalCostUsd: number;
+  callCount: number;
+  avgCostUsd: number;
+}
+
+export interface CacheStats {
+  hitRate: number;
+  cachedTokens: number;
+  cacheWriteTokens: number;
+  uncachedTokens: number;
+}
+
+export interface SessionCostSummary {
+  totalCostUsd: number;
+  totalSessions: number;
+  avgCostPerSession: number;
+}
+
+// ---- API calls ----
+
+export async function getDailyCost(since: number): Promise<DailyCostAggregate[]> {
+  return trpcVanilla.admin.inference.dailyCost.query({ since });
+}
+
+export async function getPageCost(since: number): Promise<PageCostAggregate[]> {
+  return trpcVanilla.admin.inference.pageCost.query({ since });
+}
+
+export async function getCacheStats(since: number): Promise<CacheStats> {
+  return trpcVanilla.admin.inference.cacheHitRate.query({ since });
+}
+
+export async function getSessionCost(since: number): Promise<SessionCostSummary> {
+  return trpcVanilla.admin.inference.sessionCost.query({ since });
+}