@littlebearapps/platform-admin-sdk 1.4.2 → 2.0.0

package/templates/standard/dashboard/src/pages/api/errors/stats.ts

@@ -0,0 +1,55 @@
+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({ byPriority: {}, byWorker: [], total: 0 }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const byPriority = await db
+      .prepare(
+        `SELECT priority, COUNT(*) as count
+         FROM error_occurrences WHERE status = 'open'
+         GROUP BY priority
+         LIMIT 10`
+      )
+      .all<{ priority: string; count: number }>();
+
+    const byWorker = await db
+      .prepare(
+        `SELECT script_name, COUNT(*) as count
+         FROM error_occurrences WHERE status = 'open'
+         GROUP BY script_name
+         ORDER BY count DESC
+         LIMIT 10`
+      )
+      .all<{ script_name: string; count: number }>();
+
+    const total = await db
+      .prepare(`SELECT COUNT(*) as count FROM error_occurrences WHERE status = 'open' LIMIT 1`)
+      .first<{ count: number }>();
+
+    const priorityMap: Record<string, number> = {};
+    for (const row of byPriority.results ?? []) {
+      priorityMap[row.priority] = row.count;
+    }
+
+    return new Response(
+      JSON.stringify({
+        byPriority: priorityMap,
+        byWorker: byWorker.results ?? [],
+        total: total?.count ?? 0,
+      }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=30' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ byPriority: {}, byWorker: [], total: 0 }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/standard/dashboard/src/pages/api/health/audit-history.ts

@@ -0,0 +1,37 @@
+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({ history: [] }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '20'), 100);
+
+  try {
+    const history = await db
+      .prepare(
+        `SELECT id, project, scan_type, ai_judge_score, sdk_score,
+                observability_score, cost_protection_score, security_score,
+                scan_date
+         FROM audit_results
+         ORDER BY scan_date DESC
+         LIMIT ?`
+      )
+      .bind(limit)
+      .all();
+
+    return new Response(
+      JSON.stringify({ history: history.results ?? [] }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=120' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ history: [] }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/standard/dashboard/src/pages/api/health/dlq.ts

@@ -0,0 +1,43 @@
+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({ depth: 0, oldestAge: null, status: 'unknown' }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const depth = await db
+      .prepare(`SELECT COUNT(*) as count FROM dlq_messages WHERE status = 'pending' LIMIT 1`)
+      .first<{ count: number }>();
+
+    const oldest = await db
+      .prepare(
+        `SELECT MIN(received_at) as oldest
+         FROM dlq_messages WHERE status = 'pending'
+         LIMIT 1`
+      )
+      .first<{ oldest: string | null }>();
+
+    let oldestAgeMinutes: number | null = null;
+    if (oldest?.oldest) {
+      oldestAgeMinutes = Math.round((Date.now() - new Date(oldest.oldest).getTime()) / 60000);
+    }
+
+    const dlqDepth = depth?.count ?? 0;
+    const status = dlqDepth === 0 ? 'healthy' : dlqDepth < 100 ? 'warning' : 'critical';
+
+    return new Response(
+      JSON.stringify({ depth: dlqDepth, oldestAgeMinutes, status }),
+      { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'max-age=30' } }
+    );
+  } catch {
+    return new Response(JSON.stringify({ depth: 0, oldestAgeMinutes: null, status: 'unknown' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/standard/dashboard/src/pages/circuit-breakers.astro

@@ -0,0 +1,13 @@
+---
+import DashboardLayout from '../layouts/DashboardLayout.astro';
+import { CircuitBreakerPanel } from '../components/health/CircuitBreakerPanel';
+import { CircuitBreakerEvents } from '../components/health/CircuitBreakerEvents';
+---
+
+<DashboardLayout title="Circuit Breakers">
+  <div class="max-w-5xl mx-auto space-y-4">
+    <h2 class="text-xl font-bold text-gray-900 dark:text-white mb-4">Circuit Breakers</h2>
+    <CircuitBreakerPanel client:load />
+    <CircuitBreakerEvents client:load />
+  </div>
+</DashboardLayout>

package/templates/standard/dashboard/src/pages/errors.astro

@@ -0,0 +1,13 @@
+---
+import DashboardLayout from '../../layouts/DashboardLayout.astro';
+import { ErrorsTable } from '../../components/errors/ErrorsTable';
+import { ErrorStats } from '../../components/errors/ErrorStats';
+---
+
+<DashboardLayout title="Errors">
+  <div class="max-w-7xl mx-auto space-y-6">
+    <h2 class="text-xl font-bold text-gray-900 dark:text-white mb-4">Error Management</h2>
+    <ErrorStats client:load />
+    <ErrorsTable client:load />
+  </div>
+</DashboardLayout>

package/templates/standard/dashboard/src/pages/health.astro

@@ -0,0 +1,11 @@
+---
+import DashboardLayout from '../../layouts/DashboardLayout.astro';
+import { HealthTabs } from '../../components/health/HealthTabs';
+---
+
+<DashboardLayout title="Health">
+  <div class="max-w-7xl mx-auto">
+    <h2 class="text-xl font-bold text-gray-900 dark:text-white mb-4">System Health</h2>
+    <HealthTabs client:load />
+  </div>
+</DashboardLayout>

package/templates/standard/migrations/009_topology_mapper.sql

@@ -0,0 +1,65 @@
+-- Migration 009: Topology Mapper Tables
+--
+-- Purpose: Infrastructure topology tracking for the platform-mapper worker.
+-- Stores discovered Cloudflare resources, service connections, and historical snapshots.
+--
+-- Tables:
+--   services                — Discovered/defined infrastructure services
+--   connections             — Relationships between services
+--   topology_snapshots      — Historical topology snapshots for trend analysis
+--
+-- Tier: Standard+
+-- Worker: platform-mapper (15-minute cron)
+
+-- Services discovered or defined
+CREATE TABLE IF NOT EXISTS services (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL,                    -- 'cloudflare-worker', 'cloudflare-pages', etc.
+  tier INTEGER NOT NULL,                 -- 0 (critical), 1 (high), 2 (medium)
+  status TEXT NOT NULL,                  -- 'deployed', 'partial', 'not-deployed', 'unknown'
+  version TEXT,
+  health_endpoint TEXT,
+  health_status TEXT DEFAULT 'unknown',  -- 'up', 'degraded', 'down', 'unknown'
+  last_seen TIMESTAMP,
+  metadata TEXT,                         -- JSON: Type-specific data
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_services_type ON services(type);
+CREATE INDEX IF NOT EXISTS idx_services_tier ON services(tier);
+CREATE INDEX IF NOT EXISTS idx_services_status ON services(status);
+CREATE INDEX IF NOT EXISTS idx_services_health ON services(health_status);
+
+-- Connections between services
+CREATE TABLE IF NOT EXISTS connections (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_service TEXT NOT NULL,
+  to_service TEXT NOT NULL,
+  connection_type TEXT NOT NULL,          -- 'webhook', 'api', 'data-flow', 'deployment', 'service-binding'
+  protocol TEXT,                          -- 'https', 'rest', 'queue', etc.
+  status TEXT NOT NULL,                   -- 'active', 'planned', 'not-integrated', 'broken'
+  metadata TEXT,                          -- JSON: Connection-specific data
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (from_service, to_service, connection_type),
+  FOREIGN KEY (from_service) REFERENCES services(id),
+  FOREIGN KEY (to_service) REFERENCES services(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_connections_from ON connections(from_service);
+CREATE INDEX IF NOT EXISTS idx_connections_to ON connections(to_service);
+CREATE INDEX IF NOT EXISTS idx_connections_status ON connections(status);
+
+-- Historical snapshots (for topology change tracking)
+CREATE TABLE IF NOT EXISTS topology_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  data TEXT NOT NULL,                     -- JSON: Full topology snapshot
+  change_summary TEXT,                    -- What changed since last snapshot
+  service_count INTEGER,
+  connection_count INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_snapshots_timestamp ON topology_snapshots(timestamp);

package/templates/standard/tests/unit/error-collector/capture.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Unit Tests for Error Capture Logic
+ *
+ * Covers:
+ * - shouldCapture() filtering logic
+ * - Outcome handling for all 7 non-OK outcomes
+ * - Deduplication via KV fingerprint keys
+ */
+
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { createMockKV } from '../../../tests/helpers/mock-kv';
+import { MockD1Database } from '../../../tests/helpers/mock-d1';
+
+vi.mock('@littlebearapps/platform-consumer-sdk', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    createLoggerFromEnv: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+  };
+});
+
+import { shouldCapture } from '../../../workers/lib/error-collector/capture';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTailEvent(overrides: Record<string, unknown> = {}) {
+  return {
+    scriptName: 'test-worker',
+    outcome: 'exception',
+    exceptions: [{ name: 'Error', message: 'Test error' }],
+    logs: [],
+    eventTimestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+// ===========================================================================
+// shouldCapture
+// ===========================================================================
+
+describe('shouldCapture', () => {
+  it('captures exception outcomes', () => {
+    const event = createTailEvent({ outcome: 'exception' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures exceededCpu outcomes', () => {
+    const event = createTailEvent({ outcome: 'exceededCpu' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures exceededMemory outcomes', () => {
+    const event = createTailEvent({ outcome: 'exceededMemory' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures canceled outcomes', () => {
+    const event = createTailEvent({ outcome: 'canceled' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures responseStreamDisconnected outcomes', () => {
+    const event = createTailEvent({ outcome: 'responseStreamDisconnected' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures scriptNotFound outcomes', () => {
+    const event = createTailEvent({ outcome: 'scriptNotFound' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('does not capture ok outcomes without error logs', () => {
+    const event = createTailEvent({ outcome: 'ok', exceptions: [], logs: [] });
+    expect(shouldCapture(event as never)).toBe(false);
+  });
+
+  it('captures ok outcomes with error-level logs (soft errors)', () => {
+    const event = createTailEvent({
+      outcome: 'ok',
+      exceptions: [],
+      logs: [{ level: 'error', message: ['Something failed'], timestamp: Date.now() }],
+    });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures ok outcomes with warning-level logs', () => {
+    const event = createTailEvent({
+      outcome: 'ok',
+      exceptions: [],
+      logs: [{ level: 'warn', message: ['Deprecation warning'], timestamp: Date.now() }],
+    });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('ignores events without scriptName', () => {
+    const event = createTailEvent({ scriptName: undefined, outcome: 'exception' });
+    expect(shouldCapture(event as never)).toBe(false);
+  });
+});

package/templates/standard/tests/unit/error-collector/fingerprint.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Unit Tests for Error Fingerprinting
+ *
+ * Covers:
+ * - Error classification by outcome type
+ * - Transient error detection (quota, rate-limit, timeout)
+ * - Message normalisation (variable stripping)
+ * - Fingerprint stability (same error = same fingerprint)
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('@littlebearapps/platform-consumer-sdk', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    createLoggerFromEnv: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+  };
+});
+
+import {
+  classifyError,
+  generateFingerprint,
+  normalizeMessage,
+  isTransientError,
+} from '../../../workers/lib/error-collector/fingerprint';
+
+// ===========================================================================
+// Classification
+// ===========================================================================
+
+describe('classifyError', () => {
+  it('classifies exception as P0-P2 based on severity', () => {
+    const result = classifyError({
+      outcome: 'exception',
+      scriptName: 'test-worker',
+      message: 'Uncaught ReferenceError: foo is not defined',
+      logs: [],
+    } as never);
+
+    expect(result).toBeDefined();
+    expect(['P0', 'P1', 'P2']).toContain(result.priority);
+  });
+
+  it('classifies exceededCpu as P0', () => {
+    const result = classifyError({
+      outcome: 'exceededCpu',
+      scriptName: 'test-worker',
+      message: 'Worker exceeded CPU time limit',
+      logs: [],
+    } as never);
+
+    expect(result.priority).toBe('P0');
+  });
+
+  it('classifies canceled as P2', () => {
+    const result = classifyError({
+      outcome: 'canceled',
+      scriptName: 'test-worker',
+      message: 'Request was canceled',
+      logs: [],
+    } as never);
+
+    expect(result.priority).toBe('P2');
+  });
+
+  it('classifies soft_error from logs as P2-P3', () => {
+    const result = classifyError({
+      outcome: 'ok',
+      scriptName: 'test-worker',
+      message: 'Soft error captured via console.error',
+      logs: [{ level: 'error', message: ['Something failed'] }],
+    } as never);
+
+    expect(['P2', 'P3']).toContain(result.priority);
+  });
+});
+
+// ===========================================================================
+// Transient Detection
+// ===========================================================================
+
+describe('isTransientError', () => {
+  it('detects quota-exhausted as transient', () => {
+    expect(isTransientError('D1_ERROR: too many requests (quota exhausted)')).toBe(true);
+  });
+
+  it('detects rate-limited as transient', () => {
+    expect(isTransientError('Rate limited: try again in 30 seconds')).toBe(true);
+  });
+
+  it('detects timeout as transient', () => {
+    expect(isTransientError('Network request timed out after 30000ms')).toBe(true);
+  });
+
+  it('does not flag regular errors as transient', () => {
+    expect(isTransientError('TypeError: Cannot read property of null')).toBe(false);
+  });
+});
+
+// ===========================================================================
+// Message Normalisation
+// ===========================================================================
+
+describe('normalizeMessage', () => {
+  it('strips UUIDs from messages', () => {
+    const result = normalizeMessage('Error for user a1b2c3d4-e5f6-7890-abcd-ef1234567890');
+    expect(result).not.toContain('a1b2c3d4');
+    expect(result).toContain('<UUID>');
+  });
+
+  it('strips numeric IDs from messages', () => {
+    const result = normalizeMessage('Failed to process request 1234567890');
+    expect(result).not.toContain('1234567890');
+  });
+
+  it('strips timestamps from messages', () => {
+    const result = normalizeMessage('Error at 2026-03-05T12:00:00Z in handler');
+    expect(result).not.toContain('2026-03-05');
+  });
+
+  it('preserves error type prefixes', () => {
+    const result = normalizeMessage('TypeError: Cannot read property of null');
+    expect(result).toContain('TypeError');
+  });
+});
+
+// ===========================================================================
+// Fingerprint Stability
+// ===========================================================================
+
+describe('generateFingerprint', () => {
+  it('produces consistent fingerprint for same error', () => {
+    const fp1 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    const fp2 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    expect(fp1).toBe(fp2);
+  });
+
+  it('produces different fingerprints for different errors', () => {
+    const fp1 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    const fp2 = generateFingerprint('test-worker', 'RangeError: Maximum call stack exceeded');
+    expect(fp1).not.toBe(fp2);
+  });
+
+  it('produces different fingerprints for different workers', () => {
+    const fp1 = generateFingerprint('worker-a', 'Error: timeout');
+    const fp2 = generateFingerprint('worker-b', 'Error: timeout');
+    expect(fp1).not.toBe(fp2);
+  });
+});

package/templates/standard/workers/lib/error-collector/email-health-alerts.ts

@@ -198,14 +198,48 @@ export async function processEmailHealthAlerts(
     }
 
     try {
-      // Create a focused issue for this specific check failure
+      const issueTitle = `Email Health: ${brandName} ${failure.check_type} failing`;
+
+      // Search for an existing OPEN issue before creating a new one.
+      // This prevents daily duplicate issues when a problem persists across days.
+      const openIssues = await github.searchIssues(
+        owner,
+        repo,
+        `"${issueTitle}" is:open label:cf:email-health`
+      );
+
+      if (openIssues.length > 0) {
+        const existing = openIssues[0];
+        await github.addComment(
+          owner,
+          repo,
+          existing.number,
+          `### Still failing (${getDateKey()})\n\n` +
+            `Check \`${failure.check_type}\` continues to fail: ${failure.error_msg}\n\n` +
+            `Run ID: \`${event.run_id}\``
+        );
+        await setDedup(env.PLATFORM_CACHE, event.brand_id, failure.check_type, existing.number);
+
+        console.log(
+          `Commented on existing email health issue #${existing.number} for ${event.brand_id}:${failure.check_type}`
+        );
+
+        results.skipped++;
+        results.skippedChecks.push({
+          check_type: failure.check_type,
+          reason: `Commented on existing issue #${existing.number}`,
+        });
+        continue;
+      }
+
+      // No existing open issue — create a new one
       const issue = await github.createIssue({
         owner,
         repo,
-        title: `Email Health: ${brandName} ${failure.check_type} failing`,
+        title: issueTitle,
         body: formatIssueBody({
           ...event,
-          failures: [failure], // Only include this specific failure
+          failures: [failure],
         }),
         labels: EMAIL_HEALTH_LABELS,
       });

package/templates/standard/workers/lib/error-collector/gap-alerts.ts

@@ -237,7 +237,38 @@ export async function processGapAlert(
   const github = new GitHubClient(env);
 
   try {
-    // Create the issue
+    // Search for an existing OPEN gap alert issue before creating a new one.
+    // This prevents daily duplicate issues when coverage stays below threshold.
+    const openIssues = await github.searchIssues(
+      owner,
+      repo,
+      `"Data Coverage Gap: ${event.project}" is:open label:cf:gap-alert`
+    );
+
+    if (openIssues.length > 0) {
+      const existing = openIssues[0];
+      await github.addComment(
+        owner,
+        repo,
+        existing.number,
+        `### Coverage still below threshold (${getDateKey()})\n\n` +
+          `Coverage: **${event.coveragePct}%** (threshold: 90%)\n` +
+          `Hours with data: ${event.hoursWithData}/${event.expectedHours}\n` +
+          `Missing hours: ${event.missingHours.length}`
+      );
+      await setGapAlertDedup(env.PLATFORM_CACHE, event.project, existing.number);
+
+      console.log(
+        `Commented on existing gap alert issue #${existing.number} for ${event.project}`
+      );
+
+      return {
+        processed: false,
+        skipped: `Commented on existing issue #${existing.number}`,
+      };
+    }
+
+    // No existing open issue — create a new one
     const issue = await github.createIssue({
       owner,
       repo,