@littlebearapps/platform-admin-sdk 2.1.0 → 2.2.0

package/templates/standard/dashboard/src/pages/api/infrastructure/alerts.ts

@@ -0,0 +1,85 @@
+/**
+ * GET /api/infrastructure/alerts - Fetch recent alerts from D1
+ * Reads from the `notifications` table (the active unified notification system).
+ * The legacy `alerts` table exists but has no data.
+ *
+ * Maps notification fields to the Alert shape that AlertHistory.tsx expects.
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+interface NotificationRow {
+  id: string;
+  category: string;
+  priority: string;
+  source: string;
+  title: string;
+  description: string | null;
+  project: string | null;
+  createdAt: number;
+}
+
+/** Map notification priority to alert severity */
+function priorityToSeverity(priority: string): 'info' | 'warning' | 'critical' {
+  switch (priority) {
+    case 'critical':
+    case 'high':
+      return 'critical';
+    case 'medium':
+      return 'warning';
+    default:
+      return 'info';
+  }
+}
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+  const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+
+  if (!db) {
+    return new Response(JSON.stringify({ error: 'Database not configured', alerts: [] }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const result = await db
+      .prepare(
+        `SELECT
+           id, category, priority, source, title, description, project,
+           created_at AS createdAt
+         FROM notifications
+         WHERE created_at >= unixepoch() - (30 * 24 * 60 * 60)
+           AND (expires_at IS NULL OR expires_at > unixepoch())
+         ORDER BY created_at DESC
+         LIMIT ?`
+      )
+      .bind(limit)
+      .all<NotificationRow>();
+
+    const alerts = result.results.map((n) => ({
+      id: n.id,
+      type: n.category,
+      severity: priorityToSeverity(n.priority),
+      source: n.project ? `${n.source} (${n.project})` : n.source,
+      message: n.description ? `${n.title}: ${n.description}` : n.title,
+      createdAt: n.createdAt,
+      acknowledgedAt: null,
+      resolvedAt: n.category === 'success' ? n.createdAt : null,
+    }));
+
+    return new Response(JSON.stringify({ alerts }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching alerts:', error);
+    return new Response(JSON.stringify({ alerts: [], error: 'Table not found or query failed' }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/standard/dashboard/src/pages/api/infrastructure/healthchecks/[id]/flips.ts

@@ -0,0 +1,110 @@
+/**
+ * GET /api/infrastructure/healthchecks/[id]/flips - Fetch status change history for a Gatus heartbeat
+ * Proxies to Gatus API with caching
+ */
+import type { APIRoute } from 'astro';
+
+import { fetchGatusEndpoint } from '../../../../../lib/infrastructure/gatus';
+
+interface Env {
+  PLATFORM_CACHE?: KVNamespace;
+  GATUS_API_URL?: string;
+}
+
+interface FlipEvent {
+  timestamp: number;
+  up: boolean;
+}
+
+interface FlipsResponse {
+  flips: FlipEvent[];
+  checkId: string;
+  cached: boolean;
+  flipsToday: number;
+  lastFailure: number | null;
+}
+
+const CACHE_TTL = 300; // 5 minutes
+
+export const GET: APIRoute = async ({ params, locals }) => {
+  const checkId = params.id;
+  if (!checkId) {
+    return new Response(JSON.stringify({ error: 'Missing check ID' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const env = locals.runtime?.env as Env | undefined;
+  const kv = env?.PLATFORM_CACHE;
+  const gatusUrl = env?.GATUS_API_URL || 'https://status.littlebearapps.com';
+
+  const cacheKey = `HEALTHCHECKS_FLIPS:${checkId}`;
+
+  try {
+    // Check cache first
+    if (kv) {
+      const cached = await kv.get(cacheKey, 'json');
+      if (cached) {
+        return new Response(JSON.stringify({ ...cached, cached: true }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    }
+
+    // Fetch from Gatus
+    const endpoint = await fetchGatusEndpoint(gatusUrl, checkId, kv);
+
+    // Transform Gatus events to flip events (filter out START events)
+    const flips: FlipEvent[] = (endpoint.events || [])
+      .filter((event) => event.type === 'HEALTHY' || event.type === 'UNHEALTHY')
+      .map((event) => ({
+        timestamp: Math.floor(new Date(event.timestamp).getTime() / 1000),
+        up: event.type === 'HEALTHY',
+      }));
+
+    // Sort by timestamp descending (most recent first)
+    flips.sort((a, b) => b.timestamp - a.timestamp);
+
+    // Calculate today's flips
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const todayStartTs = Math.floor(todayStart.getTime() / 1000);
+    const flipsToday = flips.filter((f) => f.timestamp >= todayStartTs).length;
+
+    // Find last failure
+    const lastDownFlip = flips.find((f) => !f.up);
+    const lastFailure = lastDownFlip?.timestamp || null;
+
+    const result: Omit<FlipsResponse, 'cached'> = {
+      flips: flips.slice(0, 20), // Return last 20 flips
+      checkId,
+      flipsToday,
+      lastFailure,
+    };
+
+    // Cache the result
+    if (kv) {
+      await kv.put(cacheKey, JSON.stringify(result), { expirationTtl: CACHE_TTL });
+    }
+
+    return new Response(JSON.stringify({ ...result, cached: false }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching heartbeat events:', error);
+    return new Response(
+      JSON.stringify({
+        error: 'Failed to fetch events',
+        flips: [],
+        checkId,
+        flipsToday: 0,
+        lastFailure: null,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/standard/dashboard/src/pages/api/infrastructure/healthchecks.ts

@@ -0,0 +1,101 @@
+/**
+ * GET /api/infrastructure/healthchecks - Fetch Gatus heartbeats
+ * Proxies to Gatus API with caching
+ */
+import type { APIRoute } from 'astro';
+
+import { fetchAllGatusStatuses } from '../../../lib/infrastructure/gatus';
+
+interface Env {
+  PLATFORM_CACHE?: KVNamespace;
+  GATUS_API_URL?: string;
+}
+
+interface HealthcheckJob {
+  id: string;
+  name: string;
+  slug: string;
+  status: 'up' | 'down' | 'grace' | 'paused' | 'new';
+  lastPing: number | null;
+  nextPing: number | null;
+  period: number;
+  grace: number;
+  nPings: number;
+  tags: string[];
+}
+
+const CACHE_KEY = 'HEALTHCHECKS_JOBS';
+const CACHE_TTL = 300; // 5 minutes
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const kv = env?.PLATFORM_CACHE;
+  const gatusUrl = env?.GATUS_API_URL || 'https://status.littlebearapps.com';
+
+  try {
+    // Check cache first
+    if (kv) {
+      const cached = await kv.get(CACHE_KEY, 'json');
+      if (cached) {
+        return new Response(JSON.stringify({ checks: cached, cached: true }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    }
+
+    // Fetch all statuses from Gatus
+    const allStatuses = await fetchAllGatusStatuses(gatusUrl);
+
+    // Filter to heartbeats and server monitors (heartbeats + hetzner)
+    const HEARTBEAT_GROUPS = new Set(['heartbeats', 'hetzner']);
+    const heartbeatEndpoints = allStatuses.filter((ep) => HEARTBEAT_GROUPS.has(ep.group));
+
+    const checks: HealthcheckJob[] = heartbeatEndpoints.map((ep) => {
+      const latestResult = ep.results.length > 0 ? ep.results[ep.results.length - 1] : null;
+
+      // Derive period from average interval between the last few results
+      let period = 900; // Default 15m
+      if (ep.results.length >= 2) {
+        const lastTwo = ep.results.slice(-2);
+        const t1 = new Date(lastTwo[0].timestamp).getTime();
+        const t2 = new Date(lastTwo[1].timestamp).getTime();
+        period = Math.round(Math.abs(t2 - t1) / 1000);
+      }
+
+      const lastPingTs = latestResult
+        ? Math.floor(new Date(latestResult.timestamp).getTime() / 1000)
+        : null;
+
+      return {
+        id: ep.key,
+        name: ep.name,
+        slug: ep.name
+          .toLowerCase()
+          .replace(/\s+/g, '-')
+          .replace(/[^a-z0-9-]/g, ''),
+        status: latestResult ? (latestResult.success ? 'up' : 'down') : 'new',
+        lastPing: lastPingTs,
+        nextPing: lastPingTs ? lastPingTs + period : null,
+        period,
+        grace: 0, // Not exposed by Gatus API
+        nPings: ep.results.length,
+        tags: [],
+      };
+    });
+
+    // Cache the result
+    if (kv) {
+      await kv.put(CACHE_KEY, JSON.stringify(checks), { expirationTtl: CACHE_TTL });
+    }
+
+    return new Response(JSON.stringify({ checks, cached: false }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching healthchecks:', error);
+    return new Response(JSON.stringify({ error: 'Failed to fetch healthchecks', checks: [] }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/standard/dashboard/src/pages/api/infrastructure/uptime/[id]/response-times.ts

@@ -0,0 +1,121 @@
+/**
+ * GET /api/infrastructure/uptime/[id]/response-times - Fetch response time history for a Gatus monitor
+ * Proxies to Gatus API with caching
+ */
+import type { APIRoute } from 'astro';
+
+import { fetchGatusEndpoint } from '../../../../../lib/infrastructure/gatus';
+
+interface Env {
+  PLATFORM_CACHE?: KVNamespace;
+  GATUS_API_URL?: string;
+}
+
+interface ResponseTimeDataPoint {
+  timestamp: number;
+  value: number;
+}
+
+interface ResponseTimesResponse {
+  dataPoints: ResponseTimeDataPoint[];
+  monitorId: string;
+  cached: boolean;
+  stats: {
+    avg: number;
+    min: number;
+    max: number;
+    trend: 'improving' | 'stable' | 'degrading';
+  };
+}
+
+const CACHE_TTL = 300; // 5 minutes
+
+export const GET: APIRoute = async ({ params, locals }) => {
+  const monitorId = params.id;
+  if (!monitorId) {
+    return new Response(JSON.stringify({ error: 'Missing monitor ID' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const env = locals.runtime?.env as Env | undefined;
+  const kv = env?.PLATFORM_CACHE;
+  const gatusUrl = env?.GATUS_API_URL || 'https://status.littlebearapps.com';
+
+  const cacheKey = `UPTIME_RESPONSE_TIMES:${monitorId}`;
+
+  try {
+    // Check cache first
+    if (kv) {
+      const cached = await kv.get(cacheKey, 'json');
+      if (cached) {
+        return new Response(JSON.stringify({ ...cached, cached: true }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    }
+
+    // Fetch from Gatus
+    const endpoint = await fetchGatusEndpoint(gatusUrl, monitorId, kv);
+
+    // Transform results to response time data points (ns → ms)
+    const dataPoints: ResponseTimeDataPoint[] = endpoint.results.map((r) => ({
+      timestamp: Math.floor(new Date(r.timestamp).getTime() / 1000),
+      value: r.duration / 1_000_000, // ns → ms
+    }));
+
+    // Calculate stats
+    const values = dataPoints.map((dp) => dp.value);
+    const avg = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+    const min = values.length > 0 ? Math.min(...values) : 0;
+    const max = values.length > 0 ? Math.max(...values) : 0;
+
+    // Calculate trend by comparing first half vs second half average
+    let trend: 'improving' | 'stable' | 'degrading' = 'stable';
+    if (values.length >= 10) {
+      const mid = Math.floor(values.length / 2);
+      const firstHalfAvg = values.slice(0, mid).reduce((a, b) => a + b, 0) / mid;
+      const secondHalfAvg = values.slice(mid).reduce((a, b) => a + b, 0) / (values.length - mid);
+      const diff = ((secondHalfAvg - firstHalfAvg) / firstHalfAvg) * 100;
+
+      if (diff < -10)
+        trend = 'improving'; // Response time decreased (faster)
+      else if (diff > 10) trend = 'degrading'; // Response time increased (slower)
+    }
+
+    const result: Omit<ResponseTimesResponse, 'cached'> = {
+      dataPoints: dataPoints.slice(0, 288), // Limit to 288 points
+      monitorId,
+      stats: {
+        avg: Math.round(avg),
+        min: Math.round(min),
+        max: Math.round(max),
+        trend,
+      },
+    };
+
+    // Cache the result
+    if (kv) {
+      await kv.put(cacheKey, JSON.stringify(result), { expirationTtl: CACHE_TTL });
+    }
+
+    return new Response(JSON.stringify({ ...result, cached: false }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching response times:', error);
+    return new Response(
+      JSON.stringify({
+        error: 'Failed to fetch response times',
+        dataPoints: [],
+        monitorId,
+        stats: { avg: 0, min: 0, max: 0, trend: 'stable' },
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/standard/dashboard/src/pages/api/infrastructure/uptime.ts

@@ -0,0 +1,89 @@
+/**
+ * GET /api/infrastructure/uptime - Fetch Gatus uptime monitors
+ * Proxies to Gatus API with caching
+ */
+import type { APIRoute } from 'astro';
+
+import {
+  fetchAllGatusStatuses,
+  calculateUptimeFromResults,
+} from '../../../lib/infrastructure/gatus';
+
+interface Env {
+  PLATFORM_CACHE?: KVNamespace;
+  GATUS_API_URL?: string;
+}
+
+interface UptimeMonitor {
+  id: string;
+  name: string;
+  url: string;
+  status: 'up' | 'down' | 'paused' | 'unknown';
+  uptimeRatio: number;
+  responseTime: number;
+  lastCheckAt: number;
+  createdAt: number;
+}
+
+const CACHE_KEY = 'UPTIME_MONITORS';
+const CACHE_TTL = 300; // 5 minutes
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const kv = env?.PLATFORM_CACHE;
+  const gatusUrl = env?.GATUS_API_URL || 'https://status.littlebearapps.com';
+
+  try {
+    // Check cache first
+    if (kv) {
+      const cached = await kv.get(CACHE_KEY, 'json');
+      if (cached) {
+        return new Response(JSON.stringify({ monitors: cached, cached: true }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    }
+
+    // Fetch all statuses from Gatus
+    const allStatuses = await fetchAllGatusStatuses(gatusUrl);
+
+    // Filter to HTTP monitors (websites, apps, certificates)
+    const UPTIME_GROUPS = new Set(['websites', 'apps', 'certificates', 'resources']);
+    const websiteEndpoints = allStatuses.filter((ep) => UPTIME_GROUPS.has(ep.group));
+
+    const monitors: UptimeMonitor[] = websiteEndpoints.map((ep) => {
+      const latestResult = ep.results.length > 0 ? ep.results[ep.results.length - 1] : null;
+
+      return {
+        id: ep.key,
+        name: ep.name,
+        url: latestResult?.hostname ? `https://${latestResult.hostname}` : `https://${ep.name}`,
+        status: latestResult ? (latestResult.success ? 'up' : 'down') : 'unknown',
+        uptimeRatio: calculateUptimeFromResults(ep.results),
+        responseTime: latestResult ? latestResult.duration / 1_000_000 : 0, // ns → ms
+        lastCheckAt: latestResult
+          ? Math.floor(new Date(latestResult.timestamp).getTime() / 1000)
+          : 0,
+        createdAt: 0, // Not available from Gatus
+      };
+    });
+
+    // Cache the result
+    if (kv) {
+      await kv.put(CACHE_KEY, JSON.stringify(monitors), { expirationTtl: CACHE_TTL });
+    }
+
+    return new Response(JSON.stringify({ monitors, cached: false }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching uptime monitors:', error);
+    return new Response(
+      JSON.stringify({ error: 'Failed to fetch uptime monitors', monitors: [] }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/standard/dashboard/src/pages/api/test/service-auth.ts

@@ -0,0 +1,178 @@
+/**
+ * Test endpoint to verify Service Auth APIs work with valid tokens
+ * This endpoint uses the stored service token secrets to test the batch endpoint
+ *
+ * Usage: GET https://admin.littlebearapps.com/api/test/service-auth
+ */
+
+import type { APIContext } from 'astro';
+
+export async function GET({ locals }: APIContext): Promise<Response> {
+  const env = locals.runtime.env as any;
+
+  // Get service token credentials from environment
+  const batchTokenId = env.BATCH_SERVICE_TOKEN_ID;
+  const batchTokenSecret = env.BATCH_SERVICE_TOKEN_SECRET;
+  const scannerTokenId = env.SCANNER_SERVICE_TOKEN_ID;
+  const scannerTokenSecret = env.SCANNER_SERVICE_TOKEN_SECRET;
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    credentials: {
+      batchTokenId: batchTokenId ? `${batchTokenId.substring(0, 8)}...` : 'NOT SET',
+      scannerTokenId: scannerTokenId ? `${scannerTokenId.substring(0, 8)}...` : 'NOT SET',
+      adminTokenId: env.ADMIN_SERVICE_TOKEN_ID
+        ? `${env.ADMIN_SERVICE_TOKEN_ID.substring(0, 8)}...`
+        : 'NOT SET',
+      hasSecrets: {
+        batch: !!batchTokenSecret,
+        scanner: !!scannerTokenSecret,
+        admin: !!env.ADMIN_SERVICE_TOKEN_SECRET,
+      },
+    },
+    tests: [] as any[],
+  };
+
+  // Test 1: Subtlety Batch API
+  try {
+    const batchResponse = await fetch(
+      'https://admin.littlebearapps.com/api/brand-copilot/subtlety/batch',
+      {
+        method: 'POST',
+        headers: {
+          'CF-Access-Client-Id': batchTokenId,
+          'CF-Access-Client-Secret': batchTokenSecret,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ limit: 1, forceRecalculate: false }),
+      }
+    );
+
+    const batchData = await batchResponse.json().catch(() => ({ error: 'Failed to parse JSON' }));
+
+    results.tests.push({
+      name: 'Subtlety Batch API',
+      endpoint: '/api/brand-copilot/subtlety/batch',
+      token: 'batch-processing',
+      status: batchResponse.status,
+      statusText: batchResponse.statusText,
+      success: batchResponse.status === 200,
+      response: batchData,
+    });
+  } catch (error: any) {
+    results.tests.push({
+      name: 'Subtlety Batch API',
+      endpoint: '/api/brand-copilot/subtlety/batch',
+      token: 'batch-processing',
+      error: error.message,
+    });
+  }
+
+  // Test 2: Scanner API
+  try {
+    const scannerResponse = await fetch(
+      'https://admin.littlebearapps.com/api/brand-copilot/scanner',
+      {
+        method: 'POST',
+        headers: {
+          'CF-Access-Client-Id': scannerTokenId,
+          'CF-Access-Client-Secret': scannerTokenSecret,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ platforms: [], source: 'test' }),
+      }
+    );
+
+    const scannerData = await scannerResponse
+      .json()
+      .catch(() => ({ error: 'Failed to parse JSON' }));
+
+    results.tests.push({
+      name: 'Scanner API',
+      endpoint: '/api/brand-copilot/scanner',
+      token: 'scanner-cron-worker',
+      status: scannerResponse.status,
+      statusText: scannerResponse.statusText,
+      success: scannerResponse.status === 200,
+      response: scannerData,
+    });
+  } catch (error: any) {
+    results.tests.push({
+      name: 'Scanner API',
+      endpoint: '/api/brand-copilot/scanner',
+      token: 'scanner-cron-worker',
+      error: error.message,
+    });
+  }
+
+  // Test 3: Semantic Backfill API (using admin token)
+  const adminTokenId = env.ADMIN_SERVICE_TOKEN_ID;
+  const adminTokenSecret = env.ADMIN_SERVICE_TOKEN_SECRET;
+
+  try {
+    const backfillResponse = await fetch(
+      'https://admin.littlebearapps.com/api/admin/semantic/backfill',
+      {
+        method: 'POST',
+        headers: {
+          'CF-Access-Client-Id': adminTokenId,
+          'CF-Access-Client-Secret': adminTokenSecret,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ limit: 1, maxDuration: 1000 }),
+      }
+    );
+
+    const backfillData = await backfillResponse
+      .json()
+      .catch(() => ({ error: 'Failed to parse JSON' }));
+
+    results.tests.push({
+      name: 'Semantic Backfill API',
+      endpoint: '/api/admin/semantic/backfill',
+      token: 'admin-tools',
+      status: backfillResponse.status,
+      statusText: backfillResponse.statusText,
+      success: backfillResponse.status === 200,
+      response: backfillData,
+    });
+  } catch (error: any) {
+    results.tests.push({
+      name: 'Semantic Backfill API',
+      endpoint: '/api/admin/semantic/backfill',
+      token: 'admin-tools',
+      error: error.message,
+    });
+  }
+
+  // Calculate summary
+  const summary = {
+    total: results.tests.length,
+    passed: results.tests.filter((t) => t.success).length,
+    failed: results.tests.filter((t) => !t.success).length,
+    passRate: Math.round(
+      (results.tests.filter((t) => t.success).length / results.tests.length) * 100
+    ),
+  };
+
+  return new Response(
+    JSON.stringify(
+      {
+        summary,
+        results,
+        message:
+          summary.passRate === 100
+            ? '✅ All Service Auth APIs working correctly with service tokens!'
+            : `⚠️ ${summary.failed} of ${summary.total} tests failed`,
+      },
+      null,
+      2
+    ),
+    {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    }
+  );
+}