@littlebearapps/platform-admin-sdk 2.0.0 → 2.2.0

package/templates/full/dashboard/src/lib/usage/providers.ts

@@ -0,0 +1,331 @@
+/**
+ * Third-Party Provider Stubs
+ *
+ * Interface definitions and fetcher stubs for third-party service usage tracking.
+ * These will be implemented incrementally as integrations are built.
+ *
+ * Supported providers (planned):
+ * - GitHub (Actions minutes, Advanced Security seats, storage)
+ * - OpenAI (API usage, tokens)
+ * - Apify (Actor runs, compute units)
+ * - Anthropic (API usage, tokens)
+ * - Resend (emails sent)
+ */
+
+/**
+ * Provider identifier
+ */
+export type ProviderId = 'github' | 'openai' | 'apify' | 'anthropic' | 'resend';
+
+/**
+ * Usage record from a third-party provider
+ */
+export interface ThirdPartyUsageRecord {
+  /** Provider identifier */
+  provider: ProviderId;
+  /** Type of resource (e.g., 'actions_minutes', 'api_tokens') */
+  resourceType: string;
+  /** Optional specific resource name */
+  resourceName?: string;
+  /** Numeric usage value */
+  usageValue: number;
+  /** Unit of measurement */
+  usageUnit: string;
+  /** Estimated cost in USD */
+  costUsd: number;
+  /** When this data was collected */
+  collectedAt: Date;
+  /** Period this usage covers */
+  periodStart: Date;
+  periodEnd: Date;
+}
+
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+  /** Provider identifier */
+  id: ProviderId;
+  /** Human-readable name */
+  name: string;
+  /** Whether the provider is currently enabled */
+  enabled: boolean;
+  /** API key environment variable name */
+  apiKeyEnvVar: string;
+  /** Pricing model description */
+  pricingModel: string;
+  /** Documentation URL */
+  docsUrl: string;
+}
+
+/**
+ * Provider interface for fetching usage data
+ */
+export interface Provider {
+  /** Provider configuration */
+  config: ProviderConfig;
+
+  /**
+   * Fetch current usage data from the provider
+   * @param apiKey - API key for authentication
+   * @param options - Additional fetch options
+   * @returns Array of usage records
+   */
+  fetchUsage(
+    apiKey: string,
+    options?: {
+      startDate?: Date;
+      endDate?: Date;
+      includeBreakdown?: boolean;
+    }
+  ): Promise<ThirdPartyUsageRecord[]>;
+
+  /**
+   * Check if the provider credentials are valid
+   * @param apiKey - API key to validate
+   */
+  validateCredentials(apiKey: string): Promise<boolean>;
+}
+
+/**
+ * Provider configurations
+ */
+export const PROVIDER_CONFIGS: Record<ProviderId, ProviderConfig> = {
+  github: {
+    id: 'github',
+    name: 'GitHub',
+    enabled: true,
+    apiKeyEnvVar: 'GITHUB_TOKEN',
+    pricingModel: 'Actions minutes, Advanced Security seats, storage',
+    docsUrl: 'https://docs.github.com/en/billing',
+  },
+  openai: {
+    id: 'openai',
+    name: 'OpenAI',
+    enabled: false,
+    apiKeyEnvVar: 'OPENAI_ADMIN_API_KEY',
+    pricingModel: 'Per-token pricing for API usage',
+    docsUrl: 'https://platform.openai.com/docs/api-reference/usage',
+  },
+  apify: {
+    id: 'apify',
+    name: 'Apify',
+    enabled: false,
+    apiKeyEnvVar: 'APIFY_API_KEY',
+    pricingModel: 'Compute units for actor runs',
+    docsUrl: 'https://docs.apify.com/platform/billing',
+  },
+  anthropic: {
+    id: 'anthropic',
+    name: 'Anthropic',
+    enabled: false,
+    apiKeyEnvVar: 'ANTHROPIC_ADMIN_API_KEY',
+    pricingModel: 'Per-token pricing for Claude API',
+    docsUrl: 'https://docs.anthropic.com/en/api/admin-api',
+  },
+  resend: {
+    id: 'resend',
+    name: 'Resend',
+    enabled: false,
+    apiKeyEnvVar: 'RESEND_API_KEY',
+    pricingModel: 'Per-email pricing',
+    docsUrl: 'https://resend.com/docs/api-reference',
+  },
+};
+
+// =============================================================================
+// PROVIDER FETCHER STUBS
+// =============================================================================
+// Each stub returns an empty array with a TODO comment.
+// Implement these as integrations are built.
+// =============================================================================
+
+/**
+ * GitHub Usage Fetcher
+ *
+ * TODO: Implement GitHub billing API integration
+ * - GET /orgs/{org}/settings/billing/actions
+ * - GET /orgs/{org}/settings/billing/advanced-security
+ * - GET /orgs/{org}/settings/billing/shared-storage
+ *
+ * @see https://docs.github.com/en/rest/billing
+ */
+export async function fetchGitHubUsage(
+  _apiKey: string,
+  _options?: {
+    organization?: string;
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  // TODO: Implement GitHub billing API calls
+  // 1. Fetch Actions minutes usage
+  // 2. Fetch Advanced Security seats
+  // 3. Fetch shared storage usage
+  // 4. Calculate costs based on GitHub pricing
+  console.log('[providers] GitHub usage fetcher not yet implemented');
+  return [];
+}
+
+/**
+ * OpenAI Usage Fetcher
+ *
+ * TODO: Implement OpenAI Usage API integration
+ * - GET /v1/usage (requires admin API key: sk-admin-...)
+ *
+ * @see https://platform.openai.com/docs/api-reference/usage
+ */
+export async function fetchOpenAIUsage(
+  _apiKey: string,
+  _options?: {
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  // TODO: Implement OpenAI Usage API calls
+  // 1. Fetch token usage by model
+  // 2. Calculate costs based on model pricing
+  // 3. Group by date for time-series data
+  console.log('[providers] OpenAI usage fetcher not yet implemented');
+  return [];
+}
+
+/**
+ * Apify Usage Fetcher
+ *
+ * TODO: Implement Apify billing API integration
+ * - GET /v2/users/{userId}/usage
+ *
+ * @see https://docs.apify.com/api/v2#/reference/users/account-usage
+ */
+export async function fetchApifyUsage(
+  _apiKey: string,
+  _options?: {
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  // TODO: Implement Apify usage API calls
+  // 1. Fetch compute unit usage
+  // 2. Fetch actor run counts
+  // 3. Calculate costs based on Apify pricing
+  console.log('[providers] Apify usage fetcher not yet implemented');
+  return [];
+}
+
+/**
+ * Anthropic Usage Fetcher
+ *
+ * TODO: Implement Anthropic Admin API integration
+ * - GET /v1/organizations/{organization_id}/usage (Admin API)
+ *
+ * @see https://docs.anthropic.com/en/api/admin-api
+ */
+export async function fetchAnthropicUsage(
+  _apiKey: string,
+  _options?: {
+    organizationId?: string;
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  // TODO: Implement Anthropic Admin API calls
+  // 1. Fetch token usage by model
+  // 2. Calculate costs based on Claude pricing
+  // 3. Group by date for time-series data
+  console.log('[providers] Anthropic usage fetcher not yet implemented');
+  return [];
+}
+
+/**
+ * Resend Usage Fetcher
+ *
+ * TODO: Implement Resend API integration
+ * - No direct usage endpoint; track via webhook or count emails
+ *
+ * @see https://resend.com/docs/api-reference
+ */
+export async function fetchResendUsage(
+  _apiKey: string,
+  _options?: {
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  // TODO: Implement Resend usage tracking
+  // 1. Query sent emails count (if available)
+  // 2. Or track via our own email logs
+  // 3. Calculate costs based on Resend pricing
+  console.log('[providers] Resend usage fetcher not yet implemented');
+  return [];
+}
+
+// =============================================================================
+// AGGREGATION UTILITIES
+// =============================================================================
+
+/**
+ * Fetch usage from all enabled providers
+ */
+export async function fetchAllProviderUsage(
+  apiKeys: Partial<Record<ProviderId, string>>,
+  options?: {
+    startDate?: Date;
+    endDate?: Date;
+  }
+): Promise<ThirdPartyUsageRecord[]> {
+  const results: ThirdPartyUsageRecord[] = [];
+
+  // Only fetch from providers that have API keys configured
+  const fetchPromises: Promise<ThirdPartyUsageRecord[]>[] = [];
+
+  if (apiKeys.github) {
+    fetchPromises.push(fetchGitHubUsage(apiKeys.github, options));
+  }
+  if (apiKeys.openai) {
+    fetchPromises.push(fetchOpenAIUsage(apiKeys.openai, options));
+  }
+  if (apiKeys.apify) {
+    fetchPromises.push(fetchApifyUsage(apiKeys.apify, options));
+  }
+  if (apiKeys.anthropic) {
+    fetchPromises.push(fetchAnthropicUsage(apiKeys.anthropic, options));
+  }
+  if (apiKeys.resend) {
+    fetchPromises.push(fetchResendUsage(apiKeys.resend, options));
+  }
+
+  // Fetch all in parallel, handle individual failures gracefully
+  const settledResults = await Promise.allSettled(fetchPromises);
+
+  for (const result of settledResults) {
+    if (result.status === 'fulfilled') {
+      results.push(...result.value);
+    } else {
+      console.error('[providers] Failed to fetch from provider:', result.reason);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Calculate total third-party costs from usage records
+ */
+export function calculateThirdPartyCosts(records: ThirdPartyUsageRecord[]): {
+  byProvider: Record<ProviderId, number>;
+  total: number;
+} {
+  const byProvider: Partial<Record<ProviderId, number>> = {};
+  let total = 0;
+
+  for (const record of records) {
+    byProvider[record.provider] = (byProvider[record.provider] ?? 0) + record.costUsd;
+    total += record.costUsd;
+  }
+
+  return {
+    byProvider: byProvider as Record<ProviderId, number>,
+    total,
+  };
+}

package/templates/full/dashboard/src/pages/api/patterns/[id]/approve.ts

@@ -0,0 +1,49 @@
+/**
+ * POST /api/patterns/:id/approve - Proxy to pattern-discovery /suggestions/:id?action=approve
+ * Approves a pending pattern suggestion
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PATTERN_DISCOVERY_API?: Fetcher;
+}
+
+export const POST: APIRoute = async ({ locals, params, url }) => {
+  const api = (locals.runtime?.env as Env)?.PATTERN_DISCOVERY_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Pattern Discovery API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const { id } = params;
+  if (!id) {
+    return new Response(JSON.stringify({ error: 'Missing suggestion ID' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const by = url.searchParams.get('by') || 'dashboard';
+
+    const response = await api.fetch(
+      `https://pattern-discovery.littlebearapps.workers.dev/suggestions/${id}?action=approve&by=${by}`,
+      { method: 'POST' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error approving suggestion:', error);
+    return new Response(JSON.stringify({ error: 'Failed to approve suggestion' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/patterns/[id]/reject.ts

@@ -0,0 +1,50 @@
+/**
+ * POST /api/patterns/:id/reject - Proxy to pattern-discovery /suggestions/:id?action=reject
+ * Rejects a pending pattern suggestion
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PATTERN_DISCOVERY_API?: Fetcher;
+}
+
+export const POST: APIRoute = async ({ locals, params, url }) => {
+  const api = (locals.runtime?.env as Env)?.PATTERN_DISCOVERY_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Pattern Discovery API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const { id } = params;
+  if (!id) {
+    return new Response(JSON.stringify({ error: 'Missing suggestion ID' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const by = url.searchParams.get('by') || 'dashboard';
+    const reason = url.searchParams.get('reason') || 'Rejected via dashboard';
+
+    const response = await api.fetch(
+      `https://pattern-discovery.littlebearapps.workers.dev/suggestions/${id}?action=reject&by=${by}&reason=${encodeURIComponent(reason)}`,
+      { method: 'POST' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error rejecting suggestion:', error);
+    return new Response(JSON.stringify({ error: 'Failed to reject suggestion' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/reports/digests/stats.ts

@@ -0,0 +1,38 @@
+/**
+ * GET /api/reports/digests/stats - Proxy to error-collector /digests/stats
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  ERROR_COLLECTOR_API?: Fetcher;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const api = (locals.runtime?.env as Env)?.ERROR_COLLECTOR_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Error Collector API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const response = await api.fetch(
+      'https://error-collector.littlebearapps.workers.dev/digests/stats',
+      { method: 'GET' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching digest stats:', error);
+    return new Response(JSON.stringify({ error: 'Failed to fetch digest stats' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

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

@@ -0,0 +1,39 @@
+/**
+ * GET /api/reports/digests - Proxy to error-collector /digests
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  ERROR_COLLECTOR_API?: Fetcher;
+}
+
+export const GET: APIRoute = async ({ request, locals }) => {
+  const api = (locals.runtime?.env as Env)?.ERROR_COLLECTOR_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Error Collector API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const url = new URL(request.url);
+    const response = await api.fetch(
+      `https://error-collector.littlebearapps.workers.dev/digests${url.search}`,
+      { method: 'GET' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching digests:', error);
+    return new Response(JSON.stringify({ error: 'Failed to fetch digests' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

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

@@ -0,0 +1,56 @@
+/**
+ * Reindex API Proxy
+ *
+ * Proxies reindex requests to platform-search worker.
+ *
+ * @module dashboard/pages/api/search/reindex
+ * @created 2026-02-03
+ * @task task-303.3
+ */
+
+import type { APIRoute } from 'astro';
+
+/**
+ * POST /api/search/reindex/:type - Reindex all documents of a content type
+ */
+export const POST: APIRoute = async ({ params, locals }) => {
+  const api = (locals.runtime?.env as { SEARCH_API?: Fetcher })?.SEARCH_API;
+  const { type } = params;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Search API not available' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  if (!type) {
+    return new Response(JSON.stringify({ error: 'Content type required' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const response = await api.fetch(
+      new Request(
+        `https://platform-search.littlebearapps.workers.dev/search/reindex/${encodeURIComponent(type)}`,
+        {
+          method: 'POST',
+        }
+      )
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Reindex error:', error);
+    return new Response(JSON.stringify({ error: 'Failed to reindex content type' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/test-reports/[id].ts

@@ -0,0 +1,102 @@
+/**
+ * Test Reports API Endpoint
+ *
+ * Serves HTML test reports from KV storage
+ * Reports are stored by platform-ingest-tester worker
+ * TTL: 7 days (passes) or 90 days (failures)
+ */
+
+export const GET = async ({ params, locals }: any) => {
+  const { id: runId } = params;
+  const env = locals.runtime.env;
+
+  if (!runId) {
+    return new Response(
+      JSON.stringify({
+        error: 'Missing run ID',
+        message: 'Run ID is required',
+      }),
+      {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  try {
+    // First, get the run from D1 to find the KV key
+    const run = await env.PLATFORM_DB.prepare(
+      `SELECT id, project, kv_report_key, timestamp, pass_rate
+       FROM runs
+       WHERE id = ?`
+    )
+      .bind(runId)
+      .first();
+
+    if (!run) {
+      return new Response(
+        JSON.stringify({
+          error: 'Run not found',
+          message: `No test run found with ID: ${runId}`,
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    if (!run.kv_report_key) {
+      return new Response(
+        JSON.stringify({
+          error: 'Report not available',
+          message: 'HTML report was not uploaded for this run',
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Fetch HTML report from KV
+    const htmlReport = await env.PLATFORM_CACHE.get(run.kv_report_key);
+
+    if (!htmlReport) {
+      return new Response(
+        JSON.stringify({
+          error: 'Report expired',
+          message: 'HTML report has expired or been deleted (TTL: 7d for passes, 90d for failures)',
+        }),
+        {
+          status: 410, // Gone
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Return HTML report
+    return new Response(htmlReport, {
+      headers: {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'public, max-age=3600', // Cache for 1 hour
+        'X-Run-ID': runId,
+        'X-Project': run.project as string,
+        'X-Timestamp': run.timestamp as string,
+      },
+    });
+  } catch (error: any) {
+    console.error('Failed to fetch test report:', error);
+
+    return new Response(
+      JSON.stringify({
+        error: 'Internal server error',
+        message: error.message,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};