@littlebearapps/platform-admin-sdk 1.5.0 → 2.1.0

package/templates/full/dashboard/src/pages/api/search/reindex.ts

@@ -0,0 +1,28 @@
+import type { APIRoute } from 'astro';
+
+export const POST: APIRoute = async ({ locals }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ error: 'Database not available' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    await db
+      .prepare(`INSERT INTO search_index(search_index) VALUES('rebuild')`)
+      .run();
+
+    return new Response(
+      JSON.stringify({ ok: true, message: 'FTS5 reindex started' }),
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ error: 'Reindex failed' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/search/stats.ts

@@ -0,0 +1,27 @@
+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({ indexed: 0, lastUpdated: null }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const count = await db
+      .prepare(`SELECT COUNT(*) as count FROM search_index LIMIT 1`)
+      .first<{ count: number }>();
+
+    return new Response(
+      JSON.stringify({ indexed: count?.count ?? 0 }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ indexed: 0 }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/settings/index.ts

@@ -0,0 +1,37 @@
+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({ settings: {} }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const rows = await db
+      .prepare(
+        `SELECT key, value, updated_at
+         FROM platform_settings
+         ORDER BY key ASC
+         LIMIT 200`
+      )
+      .all<{ key: string; value: string; updated_at: string }>();
+
+    const settings: Record<string, { value: string; updatedAt: string }> = {};
+    for (const row of rows.results ?? []) {
+      settings[row.key] = { value: row.value, updatedAt: row.updated_at };
+    }
+
+    return new Response(
+      JSON.stringify({ settings }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=30' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ settings: {} }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/settings/update.ts

@@ -0,0 +1,41 @@
+import type { APIRoute } from 'astro';
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ error: 'Database not available' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const body = (await request.json()) as { key?: string; value?: string };
+    if (!body.key || body.value === undefined) {
+      return new Response(JSON.stringify({ error: 'key and value are required' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    await db
+      .prepare(
+        `INSERT INTO platform_settings (key, value, updated_at)
+         VALUES (?, ?, datetime('now'))
+         ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+      )
+      .bind(body.key, body.value)
+      .run();
+
+    return new Response(
+      JSON.stringify({ ok: true, key: body.key }),
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ error: 'Update failed' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/topology/index.ts

@@ -0,0 +1,56 @@
+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({ nodes: [], edges: [] }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const [workers, bindings] = await Promise.all([
+      db
+        .prepare(
+          `SELECT script_name, project, worker_type, last_seen_at
+           FROM resource_project_mapping
+           WHERE resource_type = 'worker'
+           ORDER BY script_name ASC
+           LIMIT 100`
+        )
+        .all(),
+      db
+        .prepare(
+          `SELECT source_worker, target_worker, binding_type
+           FROM service_bindings
+           ORDER BY source_worker ASC
+           LIMIT 200`
+        )
+        .all(),
+    ]);
+
+    const nodes = (workers.results ?? []).map((w: Record<string, unknown>) => ({
+      id: w.script_name as string,
+      project: w.project as string,
+      type: w.worker_type as string,
+      lastSeen: w.last_seen_at as string,
+    }));
+
+    const edges = (bindings.results ?? []).map((b: Record<string, unknown>) => ({
+      from: b.source_worker as string,
+      to: b.target_worker as string,
+      type: b.binding_type as string,
+    }));
+
+    return new Response(
+      JSON.stringify({ nodes, edges }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=300' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ nodes: [], edges: [] }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/scripts/ops/universal-backfill.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env npx tsx
+/**
+ * Universal Backfill Script (Full Tier)
+ *
+ * Orchestrates the hourly → daily → monthly cascade with progress reporting.
+ * Runs each step in sequence, passing date ranges through the pipeline.
+ *
+ * Prerequisites:
+ *   CLOUDFLARE_API_TOKEN  — API token with Analytics:Read + D1:Write permissions
+ *   CLOUDFLARE_ACCOUNT_ID — Your Cloudflare account ID
+ *   D1_DATABASE_ID        — Your platform-metrics D1 database ID
+ *
+ * Usage:
+ *   npx tsx scripts/ops/universal-backfill.ts
+ *   npx tsx scripts/ops/universal-backfill.ts --dry-run
+ *   npx tsx scripts/ops/universal-backfill.ts --start 2026-02-01 --end 2026-02-28
+ *   npx tsx scripts/ops/universal-backfill.ts --skip-hourly
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+const SCRIPTS_DIR = resolve(import.meta.dirname);
+
+interface Args {
+  start?: string;
+  end?: string;
+  dryRun: boolean;
+  skipHourly: boolean;
+}
+
+function parseArgs(): Args {
+  const args = process.argv.slice(2);
+  const result: Args = { dryRun: false, skipHourly: false };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--start' && args[i + 1]) result.start = args[++i];
+    else if (args[i] === '--end' && args[i + 1]) result.end = args[++i];
+    else if (args[i] === '--dry-run') result.dryRun = true;
+    else if (args[i] === '--skip-hourly') result.skipHourly = true;
+  }
+
+  if (!result.start) {
+    const d = new Date();
+    d.setDate(d.getDate() - 7);
+    result.start = d.toISOString().slice(0, 10);
+  }
+  if (!result.end) {
+    result.end = new Date().toISOString().slice(0, 10);
+  }
+
+  return result;
+}
+
+function runStep(name: string, script: string, extraArgs: string[]) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`Step: ${name}`);
+  console.log('='.repeat(60));
+
+  const cmd = `npx tsx ${script} ${extraArgs.join(' ')}`;
+  console.log(`Running: ${cmd}\n`);
+
+  try {
+    execSync(cmd, { stdio: 'inherit', env: process.env });
+    console.log(`\n${name}: COMPLETE`);
+    return true;
+  } catch (err) {
+    console.error(`\n${name}: FAILED`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = parseArgs();
+  const dateArgs = [];
+  if (args.start) dateArgs.push('--start', args.start);
+  if (args.end) dateArgs.push('--end', args.end);
+  if (args.dryRun) dateArgs.push('--dry-run');
+
+  console.log('Universal Backfill Pipeline');
+  console.log(`Range: ${args.start} → ${args.end}`);
+  console.log(`Dry run: ${args.dryRun}`);
+  console.log(`Skip hourly: ${args.skipHourly}`);
+
+  const startTime = Date.now();
+  const results: Array<{ step: string; success: boolean }> = [];
+
+  // Step 1: Hourly backfill (optional — requires GraphQL API, rate-limited)
+  if (!args.skipHourly) {
+    const success = runStep(
+      '1/3: Hourly Backfill',
+      resolve(SCRIPTS_DIR, 'backfill-cloudflare-hourly.ts'),
+      dateArgs
+    );
+    results.push({ step: 'Hourly', success });
+    if (!success && !args.dryRun) {
+      console.warn('\nHourly backfill failed — continuing with daily rollups using existing hourly data.');
+    }
+  } else {
+    console.log('\nSkipping hourly backfill (--skip-hourly)');
+    results.push({ step: 'Hourly', success: true });
+  }
+
+  // Step 2: Daily rollups
+  const dailySuccess = runStep(
+    '2/3: Daily Rollups',
+    resolve(SCRIPTS_DIR, 'backfill-cloudflare-daily.ts'),
+    dateArgs
+  );
+  results.push({ step: 'Daily', success: dailySuccess });
+
+  // Step 3: Monthly rollups
+  const monthStart = args.start?.slice(0, 7) ?? '';
+  const monthEnd = args.end?.slice(0, 7) ?? '';
+  const monthlyArgs = [];
+  if (monthStart) monthlyArgs.push('--start', monthStart);
+  if (monthEnd) monthlyArgs.push('--end', monthEnd);
+  if (args.dryRun) monthlyArgs.push('--dry-run');
+
+  const monthlySuccess = runStep(
+    '3/3: Monthly Rollups',
+    resolve(SCRIPTS_DIR, 'backfill-monthly-rollups.ts'),
+    monthlyArgs
+  );
+  results.push({ step: 'Monthly', success: monthlySuccess });
+
+  // Summary
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  console.log(`\n${'='.repeat(60)}`);
+  console.log('Pipeline Summary');
+  console.log('='.repeat(60));
+  for (const r of results) {
+    console.log(`  ${r.success ? 'PASS' : 'FAIL'} ${r.step}`);
+  }
+  console.log(`\nTotal time: ${elapsed}s`);
+
+  const failed = results.filter((r) => !r.success);
+  if (failed.length > 0) {
+    console.error(`\n${failed.length} step(s) failed.`);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/templates/shared/.github/workflows/contract-check.yml.hbs

@@ -0,0 +1,42 @@
+# Contract Schema Validation
+#
+# Validates JSON schemas and TypeScript types match expected contracts.
+# Runs schema validation against fixture data.
+#
+# Checks performed:
+# - JSON schema validation (envelope, error_report)
+# - TypeScript type compilation
+# - Contract fixture validation
+
+name: Contract Check
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'contracts/**'
+      - 'tests/contract/**'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'contracts/**'
+      - 'tests/contract/**'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - run: npm ci
+
+      - name: Validate schemas
+        run: npm run validate:schemas
+
+      - name: Run contract tests
+        run: npx vitest run tests/contract/

package/templates/shared/.github/workflows/dashboard-deploy.yml.hbs

@@ -0,0 +1,39 @@
+name: Deploy Dashboard
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'dashboard/**'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      deployments: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: dashboard/package-lock.json
+
+      - name: Install dependencies
+        working-directory: dashboard
+        run: npm ci
+
+      - name: Build
+        working-directory: dashboard
+        run: npm run build
+
+      - name: Deploy to Cloudflare Pages
+        uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: $\{{ secrets.CLOUDFLARE_API_TOKEN }}
+          accountId: $\{{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          command: pages deploy dist --project-name={{projectSlug}}-dashboard
+          workingDirectory: dashboard

package/templates/shared/.github/workflows/security.yml

@@ -0,0 +1,33 @@
+# Security Scanning
+#
+# Runs dependency audit and secret detection on pushes and PRs.
+
+name: Security
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - run: npm ci
+
+      - name: Audit dependencies
+        run: npm audit --audit-level=high
+        continue-on-error: true
+
+      - name: Check for secrets
+        uses: trufflesecurity/trufflehog@main
+        with:
+          extra_args: --only-verified

package/templates/shared/dashboard/src/components/Nav.astro.hbs

@@ -13,6 +13,7 @@ const navItems: NavItem[] = [
 {{#if isStandard}}
   { href: '/health', label: 'Health', icon: 'activity' },
   { href: '/errors', label: 'Errors', icon: 'alert-triangle' },
+  { href: '/circuit-breakers', label: 'Breakers', icon: 'zap' },
 {{/if}}
 {{#if isFull}}
   { href: '/notifications', label: 'Notifications', icon: 'bell' },
@@ -47,6 +48,7 @@ function isActive(href: string): boolean {
           {item.icon === 'server' && '\u229E'}
           {item.icon === 'activity' && '\u2661'}
           {item.icon === 'alert-triangle' && '\u25B3'}
+          {item.icon === 'zap' && '\u26A1'}
           {item.icon === 'bell' && '\uD83D\uDD14'}
           {item.icon === 'settings' && '\u2699'}
         </span>

package/templates/shared/dashboard/src/components/infrastructure/AlertHistory.tsx

@@ -0,0 +1,57 @@
+import { useState, useEffect } from 'react';
+import { LoadingSkeleton } from '../ui/LoadingSkeleton';
+import { EmptyState } from '../ui/EmptyState';
+
+interface Alert {
+  id: number;
+  title: string;
+  severity: string;
+  source: string;
+  created_at: string;
+  resolved_at?: string;
+}
+
+export function AlertHistory() {
+  const [alerts, setAlerts] = useState<Alert[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetch('/api/usage/anomalies?limit=20')
+      .then((r) => r.json())
+      .then((data: { anomalies: Alert[] }) => {
+        setAlerts(data.anomalies ?? []);
+        setLoading(false);
+      })
+      .catch(() => setLoading(false));
+  }, []);
+
+  if (loading) return <LoadingSkeleton lines={3} />;
+  if (alerts.length === 0) return <EmptyState title="No alerts" description="No recent alerts or anomalies detected." />;
+
+  const severityColour: Record<string, string> = {
+    critical: 'text-red-600 dark:text-red-400',
+    warning: 'text-yellow-600 dark:text-yellow-400',
+    info: 'text-blue-600 dark:text-blue-400',
+  };
+
+  return (
+    <div className="space-y-2">
+      {alerts.map((a) => (
+        <div
+          key={a.id}
+          className="flex items-start justify-between gap-3 py-2 px-3 bg-white dark:bg-gray-800 rounded border border-gray-200 dark:border-gray-700"
+        >
+          <div className="min-w-0">
+            <p className={`text-sm font-medium ${severityColour[a.severity] ?? 'text-gray-900 dark:text-white'}`}>
+              {a.title}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">{a.source}</p>
+          </div>
+          <span className="text-xs text-gray-400 dark:text-gray-500 shrink-0">
+            {new Date(a.created_at).toLocaleDateString()}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}

package/templates/shared/dashboard/src/components/infrastructure/InfrastructureStats.tsx

@@ -0,0 +1,73 @@
+import { useState, useEffect } from 'react';
+import { LoadingSkeleton } from '../ui/LoadingSkeleton';
+
+interface Stats {
+  services: {
+    total: number;
+    byStatus: Record<string, number>;
+    byType: Record<string, number>;
+    byProject: Record<string, number>;
+  };
+  alerts: {
+    total: number;
+    unacknowledged: number;
+    critical: number;
+  };
+}
+
+export function InfrastructureStats() {
+  const [data, setData] = useState<Stats | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetch('/api/infrastructure/stats')
+      .then(res => res.json())
+      .then((stats: Stats) => { setData(stats); setLoading(false); })
+      .catch(() => setLoading(false));
+  }, []);
+
+  if (loading) return <LoadingSkeleton lines={4} />;
+
+  if (!data) {
+    return <p className="text-sm text-gray-500 dark:text-gray-400">No infrastructure data available.</p>;
+  }
+
+  const cards = [
+    { label: 'Total Services', value: data.services.total, icon: '\u229E' },
+    { label: 'Deployed', value: data.services.byStatus.deployed ?? 0, icon: '\u2713' },
+    { label: 'Alerts', value: data.alerts.total, icon: '\u25B3' },
+    { label: 'Critical', value: data.alerts.critical, icon: '\u26A0' },
+  ];
+
+  return (
+    <div className="space-y-4">
+      <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+        {cards.map(card => (
+          <div key={card.label} className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+            <div className="flex items-center gap-2 mb-1">
+              <span className="opacity-50">{card.icon}</span>
+              <span className="text-xs text-gray-500 dark:text-gray-400 uppercase tracking-wide">{card.label}</span>
+            </div>
+            <p className="text-2xl font-bold text-gray-900 dark:text-white">{card.value}</p>
+          </div>
+        ))}
+      </div>
+
+      {Object.keys(data.services.byType).length > 0 && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <h3 className="text-sm font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wide mb-3">
+            By Resource Type
+          </h3>
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-2">
+            {Object.entries(data.services.byType).map(([type, count]) => (
+              <div key={type} className="flex items-center justify-between py-1">
+                <span className="text-sm text-gray-600 dark:text-gray-300">{type}</span>
+                <span className="text-sm font-medium text-gray-900 dark:text-white">{count}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

package/templates/shared/dashboard/src/components/infrastructure/ServiceRegistry.tsx

@@ -0,0 +1,55 @@
+import { useState, useEffect } from 'react';
+import { EmptyState } from '../ui/EmptyState';
+import { LoadingSkeleton } from '../ui/LoadingSkeleton';
+
+interface Service {
+  script_name: string;
+  project: string;
+  resource_type: string;
+  last_seen_at?: string;
+}
+
+export function ServiceRegistry() {
+  const [services, setServices] = useState<Service[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetch('/api/infrastructure/services')
+      .then((r) => r.json())
+      .then((data: { services: Service[] }) => {
+        setServices(data.services ?? []);
+        setLoading(false);
+      })
+      .catch(() => setLoading(false));
+  }, []);
+
+  if (loading) return <LoadingSkeleton lines={5} />;
+  if (services.length === 0) return <EmptyState title="No services" description="Register services via services.yaml." />;
+
+  const grouped = services.reduce<Record<string, Service[]>>((acc, s) => {
+    const key = s.project || 'unassigned';
+    (acc[key] ??= []).push(s);
+    return acc;
+  }, {});
+
+  return (
+    <div className="space-y-4">
+      {Object.entries(grouped).map(([project, svcList]) => (
+        <div key={project}>
+          <h4 className="text-xs font-semibold uppercase text-gray-500 dark:text-gray-400 mb-1">{project}</h4>
+          <div className="space-y-1">
+            {svcList.map((s) => (
+              <div
+                key={s.script_name}
+                className="flex items-center justify-between py-1 px-2 text-sm bg-white dark:bg-gray-800 rounded border border-gray-200 dark:border-gray-700"
+              >
+                <span className="font-mono text-gray-900 dark:text-white">{s.script_name}</span>
+                <span className="text-xs text-gray-400 dark:text-gray-500">{s.resource_type}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}