@littlebearapps/platform-admin-sdk 2.0.0 → 2.2.0

package/templates/shared/dashboard/src/lib/cloudflare/index.ts.hbs

@@ -0,0 +1,120 @@
+/**
+ * Cloudflare Observability Library
+ *
+ * Provides unified access to Cloudflare metrics, costs, and analytics.
+ *
+ * @module cloudflare
+ */
+
+// Cost calculator and types
+export {
+  CF_PRICING,
+  CF_FREE_LIMITS,
+  PROJECT_PATTERNS,
+  DEFAULT_ALERT_THRESHOLDS,
+  identifyProject,
+  calculateMonthlyCosts,
+  calculateProjectCosts,
+  calculateDailyCosts,
+  getThresholdLevel,
+  analyseThresholds,
+  mergeThresholds,
+  formatNumber,
+  formatCurrency,
+  type CostBreakdown,
+  type ProjectCostBreakdown,
+  type DailyUsageMetrics,
+  type ThresholdLevel,
+  type ThresholdWarning,
+  type ThresholdAnalysis,
+  type AlertServiceType,
+  type ServiceThreshold,
+  type AlertThresholds,
+} from './costs';
+
+// D1 helpers
+export { getSystemHealth, type ProjectHealthMap, type HealthCheckRecord } from './d1';
+
+// Analytics Engine client
+export {
+  queryAnalyticsEngine,
+  selectFromAnalytics,
+  AnalyticsEngineError,
+  type AnalyticsEngineConfig,
+  type QueryResult,
+  type AnalyticsEngineErrorCode,
+  type AnalyticsEngineResponse,
+} from './analytics';
+
+{{#if isFull}}
+// GraphQL client and types (Full tier)
+export {
+  CloudflareGraphQL,
+  type TimePeriod,
+  type DateRange,
+  type CustomDateRangeParams,
+  type CompareMode,
+  type WorkersMetrics,
+  type D1Metrics,
+  type KVMetrics,
+  type R2Metrics,
+  type DOMetrics,
+  type VectorizeInfo,
+  type AIGatewayMetrics,
+  type PagesMetrics,
+  type SparklinePoint,
+  type SparklineData,
+  type WorkersErrorBreakdown,
+  type QueuesMetrics,
+  type CacheAnalytics,
+  type PeriodComparison,
+  type AccountUsage,
+  type EnhancedAccountUsage,
+  type WorkersAIMetrics,
+  type WorkersAISummary,
+  type AIGatewaySummary,
+  type DailyCostBreakdown,
+  type DailyCostData,
+  type CloudflareSubscription,
+  type WorkersPaidPlanInclusions,
+  type CloudflareBillingProfile,
+  type CloudflareAccountSubscriptions,
+} from './graphql';
+
+// Alerting service and types
+export {
+  getSeverityColour,
+  getSeverityEmoji,
+  formatPercentage,
+  generateAlertKey,
+  shouldSendAlert,
+  buildSlackMessage,
+  buildSummarySlackMessage,
+  sendSlackAlert,
+  evaluateWarning,
+  buildEmailHtml,
+  buildEmailText,
+  type CostSpikeAlert,
+  type AlertResult,
+  type SlackMessage,
+} from './alerting';
+
+// Project registry - D1-backed resource-to-project mapping
+export {
+  getProjects,
+  getProject,
+  identifyProjectFromRegistry,
+  getProjectResources,
+  getProjectResourcesByType,
+  getResourceCountsByProject,
+  getResourceCountByType,
+  upsertResourceMapping,
+  deleteResourceMapping,
+  createProject,
+  updateProjectStatus,
+  clearRegistryCache,
+  type Project,
+  type ResourceMapping,
+  type ResourceType,
+} from './project-registry';
+{{/if}}

package/templates/shared/dashboard/src/lib/infrastructure/types.ts

@@ -0,0 +1,116 @@
+/**
+ * Infrastructure Types
+ * TypeScript types for infrastructure monitoring dashboard
+ */
+
+export type ServiceStatus = 'deployed' | 'development' | 'deprecated' | 'paused';
+export type ServiceType = 'worker' | 'vps-app' | 'd1' | 'kv' | 'r2' | 'vectorize' | 'queue';
+export type MonitorStatus = 'up' | 'down' | 'paused' | 'unknown';
+export type HealthcheckStatus = 'up' | 'down' | 'grace' | 'paused' | 'new';
+
+export interface Service {
+  id: string;
+  name: string;
+  type: ServiceType;
+  status: ServiceStatus;
+  project: string;
+  scriptName?: string;
+  schedule?: string | null;
+  lastDeployed?: number | null;
+  endpoint?: string;
+}
+
+export interface ServiceRegistryStats {
+  total: number;
+  byStatus: Record<ServiceStatus, number>;
+  byType: Record<ServiceType, number>;
+  byProject: Record<string, number>;
+}
+
+export interface UptimeMonitor {
+  id: string;
+  name: string;
+  url: string;
+  status: MonitorStatus;
+  uptimeRatio: number; // Last 7 days (from Gatus)
+  responseTime: number; // Latest ms
+  lastCheckAt: number;
+  createdAt: number;
+}
+
+export interface HealthcheckJob {
+  id: string;
+  name: string;
+  slug: string;
+  status: HealthcheckStatus;
+  lastPing: number | null;
+  nextPing: number | null;
+  period: number; // seconds
+  grace: number; // seconds
+  nPings: number;
+  tags: string[];
+  // Optional flip summary (populated by enhanced API)
+  recentFlips?: FlipEvent[];
+  flipsToday?: number;
+  lastFailure?: number | null;
+}
+
+/**
+ * A flip represents a status change (up→down or down→up)
+ * Retrieved from Gatus events API
+ */
+export interface FlipEvent {
+  timestamp: number; // Unix timestamp
+  up: boolean; // true = went up, false = went down
+}
+
+/**
+ * A response time data point from Gatus
+ */
+export interface ResponseTimeDataPoint {
+  timestamp: number; // Unix timestamp
+  value: number; // Response time in ms
+}
+
+/**
+ * Response time stats summary
+ */
+export interface ResponseTimeStats {
+  avg: number;
+  min: number;
+  max: number;
+  trend: 'improving' | 'stable' | 'degrading';
+}
+
+export interface Alert {
+  id: string;
+  type: string;
+  severity: 'info' | 'warning' | 'critical';
+  source: string;
+  message: string;
+  createdAt: number;
+  acknowledgedAt: number | null;
+  resolvedAt: number | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface InfrastructureStats {
+  services: ServiceRegistryStats;
+  monitors: {
+    total: number;
+    up: number;
+    down: number;
+    averageUptime: number;
+  };
+  healthchecks: {
+    total: number;
+    up: number;
+    down: number;
+    grace: number;
+  };
+  alerts: {
+    total: number;
+    unacknowledged: number;
+    critical: number;
+  };
+}

package/templates/shared/dashboard/src/lib/usage/fetchWithDedup.ts

@@ -0,0 +1,101 @@
+/**
+ * Fetch with Request Deduplication
+ *
+ * Prevents duplicate API calls by:
+ * 1. Deduplicating concurrent requests to the same URL
+ * 2. Caching responses for a short TTL
+ *
+ * This is used by the unified dashboard components to prevent
+ * multiple components from making redundant API calls.
+ */
+
+interface CacheEntry<T> {
+  data: T;
+  expiresAt: number;
+}
+
+// In-flight request tracking (prevents concurrent duplicate requests)
+const pendingRequests = new Map<string, Promise<Response>>();
+
+// Response cache with TTL
+const responseCache = new Map<string, CacheEntry<unknown>>();
+
+// Default cache TTL: 5 seconds (short enough to stay fresh, long enough to dedupe)
+const DEFAULT_CACHE_TTL = 5000;
+
+/**
+ * Fetch with automatic request deduplication and short-term caching
+ */
+export async function fetchWithDedup<T>(
+  url: string,
+  options: RequestInit = {},
+  cacheTtl: number = DEFAULT_CACHE_TTL
+): Promise<T> {
+  const cacheKey = `${options.method || 'GET'}:${url}`;
+
+  // Check response cache first
+  const cached = responseCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.data as T;
+  }
+
+  // Check for in-flight request
+  const pending = pendingRequests.get(cacheKey);
+  if (pending) {
+    const response = await pending;
+    const data = await response.clone().json();
+    return data as T;
+  }
+
+  // Create new request
+  const request = fetch(url, {
+    credentials: 'include',
+    ...options,
+  });
+
+  pendingRequests.set(cacheKey, request);
+
+  try {
+    const response = await request;
+    pendingRequests.delete(cacheKey);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Cache the response
+    responseCache.set(cacheKey, {
+      data,
+      expiresAt: Date.now() + cacheTtl,
+    });
+
+    return data as T;
+  } catch (error) {
+    pendingRequests.delete(cacheKey);
+    throw error;
+  }
+}
+
+/**
+ * Clear the response cache (useful for forced refresh)
+ */
+export function clearFetchCache(urlPattern?: string): void {
+  if (urlPattern) {
+    for (const key of responseCache.keys()) {
+      if (key.includes(urlPattern)) {
+        responseCache.delete(key);
+      }
+    }
+  } else {
+    responseCache.clear();
+  }
+}
+
+/**
+ * Check if a URL is currently being fetched
+ */
+export function isFetching(url: string): boolean {
+  return pendingRequests.has(`GET:${url}`);
+}

package/templates/shared/dashboard/src/lib/usage/index.ts.hbs

@@ -0,0 +1,12 @@
+/**
+ * Usage Library Exports
+ *
+ * Centralised exports for usage-related configuration and utilities.
+ */
+
+export * from './fetchWithDedup';
+
+{{#if isFull}}
+export * from './allowance-config';
+export * from './providers';
+{{/if}}

package/templates/shared/dashboard/src/pages/api/usage/ai-models.ts

@@ -0,0 +1,235 @@
+/**
+ * AI Model Usage Breakdown API Endpoint
+ *
+ * Returns per-model usage and cost data from:
+ * - Workers AI (workersai_model_daily)
+ * - AI Gateway (aigateway_model_daily)
+ *
+ * @module pages/api/usage/ai-models
+ */
+
+import type { APIRoute } from 'astro';
+import type { D1Database } from '@cloudflare/workers-types';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+interface WorkersAIModel {
+  model: string;
+  project: string;
+  requests: number;
+  inputTokens: number;
+  outputTokens: number;
+  costUsd: number;
+}
+
+interface AIGatewayModel {
+  provider: string;
+  model: string;
+  gatewayId: string;
+  requests: number;
+  cachedRequests: number;
+  tokensIn: number;
+  tokensOut: number;
+  costUsd: number;
+}
+
+interface SuccessResponse {
+  success: true;
+  workersAI: {
+    models: WorkersAIModel[];
+    totalCostUsd: number;
+    totalRequests: number;
+  };
+  aiGateway: {
+    models: AIGatewayModel[];
+    totalCostUsd: number;
+    totalRequests: number;
+    byProvider: Record<string, { requests: number; costUsd: number }>;
+  };
+  period: { startDate: string; endDate: string };
+  responseTimeMs: number;
+}
+
+interface ErrorResponse {
+  success: false;
+  error: string;
+  code: string;
+}
+
+// =============================================================================
+// HANDLER
+// =============================================================================
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const startTime = Date.now();
+
+  const env = locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined;
+
+  if (!env?.PLATFORM_DB) {
+    const response: ErrorResponse = {
+      success: false,
+      error: 'Database binding not available',
+      code: 'BINDING_ERROR',
+    };
+    return new Response(JSON.stringify(response), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  // Parse query params
+  const periodParam = url.searchParams.get('period') ?? '30d';
+  const now = new Date();
+  let startDate: string;
+
+  if (periodParam === '7d') {
+    const d = new Date(now);
+    d.setDate(d.getDate() - 7);
+    startDate = d.toISOString().slice(0, 10);
+  } else if (periodParam === '24h') {
+    startDate = now.toISOString().slice(0, 10);
+  } else {
+    const d = new Date(now);
+    d.setDate(d.getDate() - 30);
+    startDate = d.toISOString().slice(0, 10);
+  }
+
+  const endDate = now.toISOString().slice(0, 10);
+
+  try {
+    // Query Workers AI model usage
+    const workersAIResult = await env.PLATFORM_DB.prepare(
+      `
+      SELECT
+        model,
+        project,
+        SUM(requests) as requests,
+        SUM(input_tokens) as input_tokens,
+        SUM(output_tokens) as output_tokens,
+        SUM(cost_usd) as cost_usd
+      FROM workersai_model_daily
+      WHERE snapshot_date >= ? AND snapshot_date <= ?
+      GROUP BY model, project
+      ORDER BY cost_usd DESC
+    `
+    )
+      .bind(startDate, endDate)
+      .all<{
+        model: string;
+        project: string;
+        requests: number;
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+      }>();
+
+    // Query AI Gateway model usage
+    const aiGatewayResult = await env.PLATFORM_DB.prepare(
+      `
+      SELECT
+        provider,
+        model,
+        gateway_id,
+        SUM(requests) as requests,
+        SUM(cached_requests) as cached_requests,
+        SUM(tokens_in) as tokens_in,
+        SUM(tokens_out) as tokens_out,
+        SUM(cost_usd) as cost_usd
+      FROM aigateway_model_daily
+      WHERE snapshot_date >= ? AND snapshot_date <= ?
+      GROUP BY provider, model, gateway_id
+      ORDER BY cost_usd DESC
+    `
+    )
+      .bind(startDate, endDate)
+      .all<{
+        provider: string;
+        model: string;
+        gateway_id: string;
+        requests: number;
+        cached_requests: number;
+        tokens_in: number;
+        tokens_out: number;
+        cost_usd: number;
+      }>();
+
+    // Transform Workers AI results
+    const workersAIModels: WorkersAIModel[] = (workersAIResult.results ?? []).map((row) => ({
+      model: row.model,
+      project: row.project,
+      requests: row.requests ?? 0,
+      inputTokens: row.input_tokens ?? 0,
+      outputTokens: row.output_tokens ?? 0,
+      costUsd: row.cost_usd ?? 0,
+    }));
+
+    const workersAITotalCost = workersAIModels.reduce((sum, m) => sum + m.costUsd, 0);
+    const workersAITotalRequests = workersAIModels.reduce((sum, m) => sum + m.requests, 0);
+
+    // Transform AI Gateway results
+    const aiGatewayModels: AIGatewayModel[] = (aiGatewayResult.results ?? []).map((row) => ({
+      provider: row.provider,
+      model: row.model,
+      gatewayId: row.gateway_id,
+      requests: row.requests ?? 0,
+      cachedRequests: row.cached_requests ?? 0,
+      tokensIn: row.tokens_in ?? 0,
+      tokensOut: row.tokens_out ?? 0,
+      costUsd: row.cost_usd ?? 0,
+    }));
+
+    const aiGatewayTotalCost = aiGatewayModels.reduce((sum, m) => sum + m.costUsd, 0);
+    const aiGatewayTotalRequests = aiGatewayModels.reduce((sum, m) => sum + m.requests, 0);
+
+    // Group AI Gateway by provider
+    const byProvider: Record<string, { requests: number; costUsd: number }> = {};
+    for (const m of aiGatewayModels) {
+      if (!byProvider[m.provider]) {
+        byProvider[m.provider] = { requests: 0, costUsd: 0 };
+      }
+      byProvider[m.provider].requests += m.requests;
+      byProvider[m.provider].costUsd += m.costUsd;
+    }
+
+    const response: SuccessResponse = {
+      success: true,
+      workersAI: {
+        models: workersAIModels,
+        totalCostUsd: Math.round(workersAITotalCost * 100) / 100,
+        totalRequests: workersAITotalRequests,
+      },
+      aiGateway: {
+        models: aiGatewayModels,
+        totalCostUsd: Math.round(aiGatewayTotalCost * 100) / 100,
+        totalRequests: aiGatewayTotalRequests,
+        byProvider,
+      },
+      period: { startDate, endDate },
+      responseTimeMs: Date.now() - startTime,
+    };
+
+    return new Response(JSON.stringify(response), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'public, max-age=300',
+      },
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('[AI-MODELS] Error:', errorMessage);
+
+    const response: ErrorResponse = {
+      success: false,
+      error: 'Failed to fetch AI model usage',
+      code: 'INTERNAL_ERROR',
+    };
+
+    return new Response(JSON.stringify(response), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};