@littlebearapps/platform-admin-sdk 1.4.2 → 2.0.0

package/templates/shared/dashboard/src/pages/api/overview/summary.ts

@@ -0,0 +1,311 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+  PLATFORM_CACHE?: KVNamespace;
+  USAGE_API?: Fetcher;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+  const kv = env?.PLATFORM_CACHE;
+
+  const summary = {
+    health: {
+      servicesTotal: 0,
+      servicesUp: 0,
+      servicesDown: 0,
+      uptimePct: 100,
+      lastAuditScore: null as number | null,
+      lastAuditDate: null as string | null,
+    },
+    errors: {
+      p0Count: 0,
+      p1Count: 0,
+      p2Count: 0,
+      p3Count: 0,
+      p4Count: 0,
+      newToday: 0,
+      dailyTrend: [] as number[],
+      topErrors: [] as Array<{
+        fingerprint: string;
+        message: string;
+        script_name: string;
+        priority: string;
+        occurrence_count: number;
+      }>,
+    },
+    costs: {
+      mtdSpend: 0,
+      dailyBurnRate: 0,
+      projectedMonthly: 0,
+      budgetPct: 0,
+      monthlyBudget: 100,
+      dailyTrend: [] as number[],
+    },
+    activity: {
+      notifications: [] as Array<{
+        id: string;
+        title: string;
+        category: string;
+        priority: string;
+        source: string;
+        created_at: number;
+        action_url: string | null;
+      }>,
+      pendingPatterns: 0,
+    },
+    alerts: {
+      hasP0P1: false,
+      trippedBreakers: 0,
+      warningBreakers: 0,
+      servicesDown: 0,
+    },
+    dataQuality: {
+      latestSnapshot: null as string | null,
+      snapshotAgeMinutes: -1,
+      status: 'unknown' as 'fresh' | 'stale' | 'unknown',
+    },
+  };
+
+  const promises: Promise<void>[] = [];
+
+  // 1. Service health from D1 project_registry
+  promises.push(
+    (async () => {
+      if (!db) return;
+      try {
+        const services = await db
+          .prepare(
+            `SELECT status FROM resource_project_mapping
+             WHERE resource_type = 'worker'
+             LIMIT 100`
+          )
+          .all<{ status: string }>();
+        if (services.results) {
+          summary.health.servicesTotal = services.results.length;
+          summary.health.servicesUp = services.results.filter((s) => s.status !== 'inactive').length;
+          summary.health.servicesDown = services.results.filter((s) => s.status === 'inactive').length;
+          summary.alerts.servicesDown = summary.health.servicesDown;
+        }
+      } catch {
+        // Table may not exist
+      }
+    })()
+  );
+
+  // 2. Error counts from D1
+  promises.push(
+    (async () => {
+      if (!db) return;
+      try {
+        const stats = await db
+          .prepare(
+            `SELECT priority, COUNT(*) as cnt
+             FROM error_occurrences
+             WHERE status = 'open'
+             GROUP BY priority
+             LIMIT 10`
+          )
+          .all<{ priority: string; cnt: number }>();
+        if (stats.results) {
+          for (const row of stats.results) {
+            if (row.priority === 'P0') summary.errors.p0Count = row.cnt;
+            else if (row.priority === 'P1') summary.errors.p1Count = row.cnt;
+            else if (row.priority === 'P2') summary.errors.p2Count = row.cnt;
+            else if (row.priority === 'P3') summary.errors.p3Count = row.cnt;
+            else if (row.priority === 'P4') summary.errors.p4Count = row.cnt;
+          }
+        }
+        summary.alerts.hasP0P1 = summary.errors.p0Count > 0 || summary.errors.p1Count > 0;
+      } catch {
+        // Table may not exist
+      }
+
+      // Top 3 errors
+      try {
+        const topErrors = await db
+          .prepare(
+            `SELECT fingerprint, normalized_message as message, script_name, priority, occurrence_count
+             FROM error_occurrences
+             WHERE status = 'open'
+             ORDER BY
+               CASE priority WHEN 'P0' THEN 1 WHEN 'P1' THEN 2 WHEN 'P2' THEN 3 WHEN 'P3' THEN 4 ELSE 5 END,
+               occurrence_count DESC
+             LIMIT 3`
+          )
+          .all();
+        summary.errors.topErrors = (topErrors.results ?? []) as typeof summary.errors.topErrors;
+      } catch {
+        // Table may not exist
+      }
+
+      // 7-day error trend
+      try {
+        const trend = await db
+          .prepare(
+            `SELECT DATE(first_seen_at) as day, COUNT(*) as count
+             FROM error_occurrences
+             WHERE first_seen_at >= DATE('now', '-7 days')
+             GROUP BY DATE(first_seen_at)
+             ORDER BY day ASC
+             LIMIT 7`
+          )
+          .all<{ day: string; count: number }>();
+        if (trend.results) {
+          const today = new Date();
+          const dailyCounts: number[] = [];
+          for (let i = 6; i >= 0; i--) {
+            const d = new Date(today);
+            d.setDate(d.getDate() - i);
+            const key = d.toISOString().slice(0, 10);
+            const match = trend.results.find((r) => r.day === key);
+            dailyCounts.push(match?.count ?? 0);
+          }
+          summary.errors.dailyTrend = dailyCounts;
+        }
+      } catch {
+        // Table may not exist
+      }
+    })()
+  );
+
+  // 3. Cost data from D1
+  promises.push(
+    (async () => {
+      if (!db) return;
+      try {
+        const now = new Date();
+        const billingStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString().slice(0, 10);
+
+        const costResult = await db
+          .prepare(
+            `SELECT SUM(total_cost_usd) as mtd_cost, COUNT(*) as days_tracked
+             FROM daily_usage_rollups
+             WHERE project = 'all' AND snapshot_date >= ?
+             LIMIT 1`
+          )
+          .bind(billingStart)
+          .first<{ mtd_cost: number; days_tracked: number }>();
+
+        if (costResult?.mtd_cost) {
+          summary.costs.mtdSpend = Math.round(costResult.mtd_cost * 100) / 100;
+        }
+
+        const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+        const daysSoFar = now.getDate();
+        summary.costs.dailyBurnRate = daysSoFar > 0 ? Math.round((summary.costs.mtdSpend / daysSoFar) * 100) / 100 : 0;
+        summary.costs.projectedMonthly = Math.round(summary.costs.dailyBurnRate * daysInMonth * 100) / 100;
+        summary.costs.budgetPct = summary.costs.monthlyBudget > 0
+          ? Math.round((summary.costs.projectedMonthly / summary.costs.monthlyBudget) * 100)
+          : 0;
+
+        // 7-day cost trend
+        const sevenDaysAgo = new Date();
+        sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+        const trendStart = sevenDaysAgo.toISOString().slice(0, 10);
+        const costTrend = await db
+          .prepare(
+            `SELECT snapshot_date as day, total_cost_usd as daily_cost
+             FROM daily_usage_rollups
+             WHERE project = 'all' AND snapshot_date >= ?
+             ORDER BY snapshot_date ASC
+             LIMIT 7`
+          )
+          .bind(trendStart)
+          .all<{ day: string; daily_cost: number }>();
+        if (costTrend.results) {
+          const today = new Date();
+          const dailyCosts: number[] = [];
+          for (let i = 6; i >= 0; i--) {
+            const d = new Date(today);
+            d.setDate(d.getDate() - i);
+            const key = d.toISOString().slice(0, 10);
+            const match = costTrend.results.find((r) => r.day === key);
+            dailyCosts.push(Math.round((match?.daily_cost ?? 0) * 100) / 100);
+          }
+          summary.costs.dailyTrend = dailyCosts;
+        }
+      } catch {
+        // Table may not exist
+      }
+    })()
+  );
+
+  // 4. Activity data
+  promises.push(
+    (async () => {
+      if (!db) return;
+      try {
+        const notifications = await db
+          .prepare(
+            `SELECT id, title, category, priority, source, created_at, action_url
+             FROM notifications
+             WHERE created_at >= unixepoch() - (7 * 24 * 60 * 60)
+             ORDER BY created_at DESC
+             LIMIT 5`
+          )
+          .all();
+        summary.activity.notifications = (notifications.results ?? []) as typeof summary.activity.notifications;
+      } catch {
+        // Table may not exist
+      }
+    })()
+  );
+
+  // 5. Circuit breaker status from KV
+  promises.push(
+    (async () => {
+      if (!kv) return;
+      try {
+        const cbKeys = await kv.list({ prefix: 'cb:' });
+        let tripped = 0;
+        let warning = 0;
+        for (const key of cbKeys.keys) {
+          const state = (await kv.get(key.name, 'json')) as { status?: string } | null;
+          if (state?.status === 'stopped' || state?.status === 'paused') tripped++;
+          else if (state?.status === 'warning') warning++;
+        }
+        summary.alerts.trippedBreakers = tripped;
+        summary.alerts.warningBreakers = warning;
+      } catch {
+        // KV may not be available
+      }
+    })()
+  );
+
+  // 6. Data quality
+  promises.push(
+    (async () => {
+      if (!db) return;
+      try {
+        const quality = await db
+          .prepare(
+            `SELECT MAX(snapshot_hour) as latest
+             FROM hourly_usage_snapshots
+             WHERE snapshot_hour >= datetime('now', '-24 hours') AND project = 'all'
+             LIMIT 1`
+          )
+          .first<{ latest: string | null }>();
+        if (quality?.latest) {
+          summary.dataQuality.latestSnapshot = quality.latest;
+          const ageMs = Date.now() - new Date(quality.latest + 'Z').getTime();
+          summary.dataQuality.snapshotAgeMinutes = Math.round(ageMs / 60000);
+          summary.dataQuality.status = summary.dataQuality.snapshotAgeMinutes < 120 ? 'fresh' : 'stale';
+        }
+      } catch {
+        // Table may not exist
+      }
+    })()
+  );
+
+  await Promise.all(promises);
+
+  return new Response(JSON.stringify(summary), {
+    headers: {
+      'Content-Type': 'application/json',
+      'Cache-Control': 'max-age=60',
+    },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/allowances.ts

@@ -0,0 +1,56 @@
+import type { APIRoute } from 'astro';
+import { CF_PAID_ALLOWANCES } from '../../../lib/cloudflare/costs';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+
+  const allowances: Array<{
+    resource: string;
+    allowance: number;
+    used: number;
+    pct: number;
+  }> = [];
+
+  if (db) {
+    try {
+      const monthStart = new Date();
+      monthStart.setDate(1);
+      const cutoff = monthStart.toISOString().slice(0, 10);
+
+      const result = await db
+        .prepare(
+          `SELECT SUM(d1_reads) as d1_reads, SUM(d1_writes) as d1_writes,
+                  SUM(kv_reads) as kv_reads, SUM(kv_writes) as kv_writes,
+                  SUM(worker_requests) as worker_requests
+           FROM daily_usage_rollups
+           WHERE project = 'all' AND snapshot_date >= ?
+           LIMIT 1`
+        )
+        .bind(cutoff)
+        .first<Record<string, number>>();
+
+      if (result) {
+        for (const [key, limit] of Object.entries(CF_PAID_ALLOWANCES)) {
+          const used = result[key] ?? 0;
+          allowances.push({
+            resource: key,
+            allowance: limit,
+            used,
+            pct: limit > 0 ? Math.round((used / limit) * 100) : 0,
+          });
+        }
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify({ allowances }), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=300' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/anomalies.ts

@@ -0,0 +1,45 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+
+  const anomalies: Array<{
+    id: number;
+    project: string;
+    metric: string;
+    current_value: number;
+    baseline_value: number;
+    deviation_pct: number;
+    detected_at: string;
+    status: string;
+  }> = [];
+
+  if (db) {
+    try {
+      const result = await db
+        .prepare(
+          `SELECT id, project, metric, current_value, baseline_value,
+                  deviation_pct, detected_at, status
+           FROM usage_anomalies
+           WHERE detected_at >= datetime('now', '-7 days')
+           ORDER BY detected_at DESC
+           LIMIT 20`
+        )
+        .all();
+      if (result.results) {
+        anomalies.push(...(result.results as typeof anomalies));
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify({ anomalies }), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=120' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/billing.ts

@@ -0,0 +1,53 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+
+  const now = new Date();
+  const billingStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString().slice(0, 10);
+  const billingEnd = new Date(now.getFullYear(), now.getMonth() + 1, 0).toISOString().slice(0, 10);
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  const daysSoFar = now.getDate();
+
+  const billing = {
+    cycleStart: billingStart,
+    cycleEnd: billingEnd,
+    daysInMonth,
+    daysSoFar,
+    currentSpend: 0,
+    dailyBurnRate: 0,
+    projectedMonthly: 0,
+    plan: 'workers_paid' as string,
+  };
+
+  if (db) {
+    try {
+      const result = await db
+        .prepare(
+          `SELECT SUM(total_cost_usd) as spend
+           FROM daily_usage_rollups
+           WHERE project = 'all' AND snapshot_date >= ?
+           LIMIT 1`
+        )
+        .bind(billingStart)
+        .first<{ spend: number | null }>();
+
+      if (result?.spend) {
+        billing.currentSpend = Math.round(result.spend * 100) / 100;
+        billing.dailyBurnRate = daysSoFar > 0 ? Math.round((billing.currentSpend / daysSoFar) * 100) / 100 : 0;
+        billing.projectedMonthly = Math.round(billing.dailyBurnRate * daysInMonth * 100) / 100;
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify(billing), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=300' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/circuit-breakers.ts

@@ -0,0 +1,44 @@
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ locals }) => {
+  const kv = (locals.runtime?.env as { PLATFORM_CACHE?: KVNamespace } | undefined)?.PLATFORM_CACHE;
+
+  if (!kv) {
+    return new Response(JSON.stringify({ breakers: [] }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const cbKeys = await kv.list({ prefix: 'cb:' });
+    const breakers = [];
+
+    for (const key of cbKeys.keys) {
+      const state = (await kv.get(key.name, 'json')) as {
+        status?: string;
+        feature?: string;
+        reason?: string;
+        trippedAt?: string;
+      } | null;
+      if (state) {
+        breakers.push({
+          key: key.name,
+          feature: state.feature ?? key.name.replace('cb:', ''),
+          status: state.status ?? 'unknown',
+          reason: state.reason ?? null,
+          trippedAt: state.trippedAt ?? null,
+        });
+      }
+    }
+
+    return new Response(JSON.stringify({ breakers }), {
+      headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=30' },
+    });
+  } catch (error) {
+    console.error('[circuit-breakers] Error:', error);
+    return new Response(JSON.stringify({ breakers: [], error: 'Failed to fetch circuit breakers' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/shared/dashboard/src/pages/api/usage/granular.ts

@@ -0,0 +1,50 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+  const project = url.searchParams.get('project') ?? 'all';
+  const days = Math.min(Number(url.searchParams.get('days') ?? '7'), 30);
+
+  const rows: Array<{
+    snapshot_date: string;
+    d1_reads: number;
+    d1_writes: number;
+    kv_reads: number;
+    kv_writes: number;
+    r2_reads: number;
+    r2_writes: number;
+    worker_requests: number;
+    total_cost_usd: number;
+  }> = [];
+
+  if (db) {
+    try {
+      const cutoff = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
+      const result = await db
+        .prepare(
+          `SELECT snapshot_date, d1_reads, d1_writes, kv_reads, kv_writes,
+                  r2_reads, r2_writes, worker_requests, total_cost_usd
+           FROM daily_usage_rollups
+           WHERE project = ? AND snapshot_date >= ?
+           ORDER BY snapshot_date ASC
+           LIMIT 30`
+        )
+        .bind(project, cutoff)
+        .all();
+      if (result.results) {
+        rows.push(...(result.results as typeof rows));
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify({ rows, project, days }), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/hourly.ts

@@ -0,0 +1,45 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+  const hours = Math.min(Number(url.searchParams.get('hours') ?? '24'), 168);
+
+  const snapshots: Array<{
+    snapshot_hour: string;
+    d1_reads: number;
+    d1_writes: number;
+    kv_reads: number;
+    kv_writes: number;
+    total_cost_usd: number;
+  }> = [];
+
+  if (db) {
+    try {
+      const cutoff = new Date(Date.now() - hours * 3600000).toISOString().slice(0, 19).replace('T', ' ');
+      const result = await db
+        .prepare(
+          `SELECT snapshot_hour, d1_reads, d1_writes, kv_reads, kv_writes, total_cost_usd
+           FROM hourly_usage_snapshots
+           WHERE project = 'all' AND snapshot_hour >= ?
+           ORDER BY snapshot_hour ASC
+           LIMIT 168`
+        )
+        .bind(cutoff)
+        .all();
+      if (result.results) {
+        snapshots.push(...(result.results as typeof snapshots));
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify({ snapshots, hours }), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/projects.ts

@@ -0,0 +1,51 @@
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PLATFORM_DB?: D1Database;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const env = locals.runtime?.env as Env | undefined;
+  const db = env?.PLATFORM_DB;
+
+  const projects: Array<{
+    project: string;
+    total_cost: number;
+    d1_writes: number;
+    worker_requests: number;
+    latest_date: string;
+  }> = [];
+
+  if (db) {
+    try {
+      const monthStart = new Date();
+      monthStart.setDate(1);
+      const cutoff = monthStart.toISOString().slice(0, 10);
+
+      const result = await db
+        .prepare(
+          `SELECT project,
+                  SUM(total_cost_usd) as total_cost,
+                  SUM(d1_writes) as d1_writes,
+                  SUM(worker_requests) as worker_requests,
+                  MAX(snapshot_date) as latest_date
+           FROM daily_usage_rollups
+           WHERE project != 'all' AND snapshot_date >= ?
+           GROUP BY project
+           ORDER BY total_cost DESC
+           LIMIT 20`
+        )
+        .bind(cutoff)
+        .all();
+      if (result.results) {
+        projects.push(...(result.results as typeof projects));
+      }
+    } catch {
+      // Table may not exist
+    }
+  }
+
+  return new Response(JSON.stringify({ projects }), {
+    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=300' },
+  });
+};

package/templates/shared/dashboard/src/pages/api/usage/status.ts

@@ -0,0 +1,42 @@
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ locals }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ status: 'no_database' }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const latestSnapshot = await db
+      .prepare(
+        `SELECT snapshot_hour, project, total_cost_usd
+         FROM hourly_usage_snapshots
+         WHERE project = 'all'
+         ORDER BY snapshot_hour DESC
+         LIMIT 1`
+      )
+      .first<{ snapshot_hour: string; project: string; total_cost_usd: number }>();
+
+    const featureCount = await db
+      .prepare(`SELECT COUNT(DISTINCT feature_id) as count FROM feature_usage_daily LIMIT 1`)
+      .first<{ count: number }>();
+
+    return new Response(
+      JSON.stringify({
+        status: 'active',
+        latestSnapshot: latestSnapshot?.snapshot_hour ?? null,
+        latestCost: latestSnapshot?.total_cost_usd ?? 0,
+        trackedFeatures: featureCount?.count ?? 0,
+      }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ status: 'error' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};