@littlebearapps/platform-admin-sdk 1.5.0 → 2.0.0

package/templates/full/dashboard/src/pages/api/patterns/cache-refresh.ts

@@ -0,0 +1,38 @@
+import type { APIRoute } from 'astro';
+
+export const POST: APIRoute = async ({ locals }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+  const kv = (locals.runtime?.env as { PLATFORM_CACHE?: KVNamespace } | undefined)?.PLATFORM_CACHE;
+
+  if (!db || !kv) {
+    return new Response(JSON.stringify({ error: 'Bindings not available' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const approved = await db
+      .prepare(
+        `SELECT id, pattern_type, pattern_value, error_type, priority
+         FROM transient_pattern_suggestions
+         WHERE status = 'approved'
+         ORDER BY match_count DESC
+         LIMIT 500`
+      )
+      .all();
+
+    const patterns = approved.results ?? [];
+    await kv.put('PATTERNS:DYNAMIC:APPROVED', JSON.stringify(patterns), { expirationTtl: 86400 });
+
+    return new Response(
+      JSON.stringify({ refreshed: true, count: patterns.length }),
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ error: 'Cache refresh failed' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/patterns/discover.ts

@@ -0,0 +1,36 @@
+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 {
+    const unclassified = await db
+      .prepare(
+        `SELECT fingerprint, script_name, error_message, priority, occurrence_count
+         FROM error_occurrences
+         WHERE fingerprint NOT IN (
+           SELECT pattern_value FROM transient_pattern_suggestions WHERE status = 'approved'
+         )
+         ORDER BY occurrence_count DESC
+         LIMIT 50`
+      )
+      .all();
+
+    return new Response(
+      JSON.stringify({ discovered: unclassified.results?.length ?? 0, errors: unclassified.results ?? [] }),
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ error: 'Discovery failed' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/patterns/ready-for-review.ts

@@ -0,0 +1,39 @@
+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({ patterns: [], count: 0 }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const patterns = await db
+      .prepare(
+        `SELECT s.id, s.pattern_type, s.pattern_value, s.error_type, s.priority,
+                s.match_count, s.source, s.created_at,
+                COUNT(e.id) as evidence_count
+         FROM transient_pattern_suggestions s
+         LEFT JOIN pattern_match_evidence e ON e.suggestion_id = s.id
+         WHERE s.status = 'shadow'
+           AND s.match_count >= 3
+           AND s.created_at < datetime('now', '-3 days')
+         GROUP BY s.id
+         ORDER BY s.match_count DESC
+         LIMIT 20`
+      )
+      .all();
+
+    return new Response(
+      JSON.stringify({ patterns: patterns.results ?? [], count: patterns.results?.length ?? 0 }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ patterns: [], count: 0 }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

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

@@ -0,0 +1,39 @@
+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({ byStatus: {}, total: 0 }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const counts = await db
+      .prepare(
+        `SELECT status, COUNT(*) as count
+         FROM transient_pattern_suggestions
+         GROUP BY status
+         LIMIT 10`
+      )
+      .all<{ status: string; count: number }>();
+
+    const byStatus: Record<string, number> = {};
+    let total = 0;
+    for (const row of counts.results ?? []) {
+      byStatus[row.status] = row.count;
+      total += row.count;
+    }
+
+    return new Response(
+      JSON.stringify({ byStatus, total }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=60' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ byStatus: {}, total: 0 }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/patterns/suggestions.ts

@@ -0,0 +1,43 @@
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ suggestions: [], total: 0 }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const status = url.searchParams.get('status') ?? 'pending';
+  const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '50'), 100);
+
+  try {
+    const suggestions = await db
+      .prepare(
+        `SELECT id, pattern_type, pattern_value, error_type, priority, status,
+                match_count, source, created_at, reviewed_at, reviewer_notes, is_protected
+         FROM transient_pattern_suggestions
+         WHERE status = ?
+         ORDER BY match_count DESC, created_at DESC
+         LIMIT ?`
+      )
+      .bind(status, limit)
+      .all();
+
+    const total = await db
+      .prepare(`SELECT COUNT(*) as count FROM transient_pattern_suggestions WHERE status = ? LIMIT 1`)
+      .bind(status)
+      .first<{ count: number }>();
+
+    return new Response(
+      JSON.stringify({ suggestions: suggestions.results ?? [], total: total?.count ?? 0 }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=30' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ suggestions: [], total: 0 }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/reports/audit.ts

@@ -0,0 +1,45 @@
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ reports: [] }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const project = url.searchParams.get('project');
+  const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '10'), 50);
+
+  try {
+    const query = project
+      ? `SELECT id, project, scan_type, ai_judge_score, sdk_score, observability_score,
+                cost_protection_score, security_score, scan_date, focused_dimensions
+         FROM audit_results
+         WHERE project = ?
+         ORDER BY scan_date DESC
+         LIMIT ?`
+      : `SELECT id, project, scan_type, ai_judge_score, sdk_score, observability_score,
+                cost_protection_score, security_score, scan_date, focused_dimensions
+         FROM audit_results
+         ORDER BY scan_date DESC
+         LIMIT ?`;
+
+    const stmt = project
+      ? db.prepare(query).bind(project, limit)
+      : db.prepare(query).bind(limit);
+
+    const reports = await stmt.all();
+
+    return new Response(
+      JSON.stringify({ reports: reports.results ?? [] }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=120' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ reports: [] }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/reports/usage.ts

@@ -0,0 +1,52 @@
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ locals, url }) => {
+  const db = (locals.runtime?.env as { PLATFORM_DB?: D1Database } | undefined)?.PLATFORM_DB;
+
+  if (!db) {
+    return new Response(JSON.stringify({ daily: [], monthly: [] }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const days = Math.min(parseInt(url.searchParams.get('days') ?? '30'), 90);
+  const startDate = new Date();
+  startDate.setDate(startDate.getDate() - days);
+  const startStr = startDate.toISOString().slice(0, 10);
+
+  try {
+    const [daily, monthly] = await Promise.all([
+      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 = 'all' AND snapshot_date >= ?
+           ORDER BY snapshot_date ASC
+           LIMIT 90`
+        )
+        .bind(startStr)
+        .all(),
+      db
+        .prepare(
+          `SELECT snapshot_month, d1_reads, d1_writes, kv_reads, kv_writes,
+                  r2_reads, r2_writes, worker_requests, total_cost_usd
+           FROM monthly_usage_rollups
+           WHERE project = 'all'
+           ORDER BY snapshot_month DESC
+           LIMIT 12`
+        )
+        .all(),
+    ]);
+
+    return new Response(
+      JSON.stringify({ daily: daily.results ?? [], monthly: monthly.results ?? [] }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=300' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ daily: [], monthly: [] }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

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/