feat: collection error Slack alerts, resilient usage-events parsing, demo image

- Normalize filtered-usage-events payloads (snake_case, missing fields)
- Notify Slack when cron collect fails or returns errors (env-gated)
- Add Dockerfile.demo + fly.demo.toml for optional mock-db demo deploy
- Allow data/mock.db in Docker context for demo builds

Made-with: Cursor

Author: ofershap

.dockerignore

@@ -3,6 +3,7 @@ node_modules
 .git
 data/*.db
 data/*.db-journal
+!data/mock.db
 coverage
 .env
 .env.local

Dockerfile.demo

@@ -0,0 +1,39 @@
+FROM node:22-alpine AS base
+
+FROM base AS deps
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm ci --omit=dev
+
+FROM base AS builder
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+RUN mkdir -p /app/data && chown nextjs:nodejs /app/data
+COPY --chown=nextjs:nodejs data/mock.db /app/data/tracker.db
+
+USER nextjs
+
+EXPOSE 3000
+
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+ENV DATABASE_PATH=/app/data/tracker.db
+
+CMD ["node", "server.js"]

fly.demo.toml

@@ -0,0 +1,22 @@
+app = "cursor-usage-tracker-demo"
+primary_region = "ams"
+
+[build]
+  dockerfile = "Dockerfile.demo"
+
+[env]
+  PORT = "3000"
+  NODE_ENV = "production"
+  DATABASE_PATH = "/app/data/tracker.db"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  memory = "256mb"
+  cpu_kind = "shared"
+  cpus = 1

src/app/api/cron/route.ts

@@ -3,7 +3,11 @@ import { collectAll } from "@/lib/collector";
 import { runDetection } from "@/lib/anomaly/detector";
 import { processNewAnomalies } from "@/lib/incidents";
 import { sendAlerts } from "@/lib/alerts";
-import { sendPlanExhaustionAlert, sendCycleSummary } from "@/lib/alerts/slack";
+import {
+  sendPlanExhaustionAlert,
+  sendCycleSummary,
+  sendCollectionErrorAlert,
+} from "@/lib/alerts/slack";
 import {
   getMetadata,
   setMetadata,
@@ -30,10 +34,21 @@ export async function POST(request: Request) {
   try {
     const collectionResult = await collectAll();
     results.collection = collectionResult;
+
+    if (collectionResult.errors.length > 0) {
+      const sent = await sendCollectionErrorAlert(collectionResult.errors, {
+        dashboardUrl: process.env.DASHBOARD_URL,
+      });
+      results.collectionErrorAlert = sent ? "sent" : "skipped";
+    }
   } catch (error) {
-    results.collection = {
-      error: error instanceof Error ? error.message : String(error),
-    };
+    const msg = error instanceof Error ? error.message : String(error);
+    results.collection = { error: msg };
+
+    const sent = await sendCollectionErrorAlert([msg], {
+      dashboardUrl: process.env.DASHBOARD_URL,
+    });
+    results.collectionErrorAlert = sent ? "sent" : "skipped";
   }
 
   try {

src/lib/alerts/slack.ts

@@ -347,6 +347,57 @@ export async function sendCycleSummary(
   );
 }
 
+export async function sendCollectionErrorAlert(
+  errors: string[],
+  options: { dashboardUrl?: string } = {},
+): Promise<boolean> {
+  const token = process.env.SLACK_BOT_TOKEN;
+  const channel = process.env.SLACK_CHANNEL_ID;
+  if (!token || !channel) return false;
+
+  const errorList = errors
+    .slice(0, 10)
+    .map((e) => `• ${e}`)
+    .join("\n");
+
+  const blocks: SlackBlock[] = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: ":x: Cursor — Data Collection Errors",
+        emoji: true,
+      },
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*${errors.length} error${errors.length > 1 ? "s" : ""}* during scheduled collection:\n${errorList}`,
+      },
+    },
+  ];
+
+  if (options.dashboardUrl) {
+    blocks.push({
+      type: "section",
+      text: { type: "mrkdwn", text: `<${options.dashboardUrl}|View dashboard>` },
+    });
+  }
+
+  blocks.push({
+    type: "context",
+    elements: [{ type: "mrkdwn", text: `${new Date().toISOString()} · cursor-usage-tracker` }],
+  });
+
+  return postToSlack(
+    token,
+    channel,
+    `Cursor — ${errors.length} collection error${errors.length > 1 ? "s" : ""}: ${errors[0]}`,
+    blocks,
+  );
+}
+
 export async function sendSlackBatch(
   pairs: Array<{ anomaly: Anomaly; incident: Incident }>,
   options: { dashboardUrl?: string } = {},

src/lib/cursor-client.ts

@@ -5,6 +5,7 @@ import type {
   MemberSpend,
   SpendResponse,
   GroupsResponse,
+  FilteredUsageEvent,
   FilteredUsageEventsResponse,
   AICodeCommitsResponse,
   AnalyticsDAUResponse,
@@ -25,6 +26,50 @@ interface CursorClientOptions {
   baseUrl?: string;
 }
 
+function num(v: unknown, fallback = 0): number {
+  return typeof v === "number" && !Number.isNaN(v) ? v : fallback;
+}
+
+function str(raw: Record<string, unknown>, ...keys: string[]): string {
+  for (const k of keys) {
+    const v = raw[k];
+    if (typeof v === "string" && v !== "") return v;
+    if (typeof v === "number" && !Number.isNaN(v)) return String(v);
+  }
+  return "";
+}
+
+function bool(v: unknown): boolean {
+  return v === true || v === 1 || v === "1";
+}
+
+function normalizeFilteredUsageEvent(raw: Record<string, unknown>): FilteredUsageEvent {
+  const tuRaw = raw.tokenUsage ?? raw.token_usage;
+  let tokenUsage: FilteredUsageEvent["tokenUsage"];
+  if (tuRaw && typeof tuRaw === "object") {
+    const t = tuRaw as Record<string, unknown>;
+    tokenUsage = {
+      inputTokens: num(t.inputTokens ?? t.input_tokens),
+      outputTokens: num(t.outputTokens ?? t.output_tokens),
+      cacheWriteTokens: num(t.cacheWriteTokens ?? t.cache_write_tokens),
+      cacheReadTokens: num(t.cacheReadTokens ?? t.cache_read_tokens),
+      totalCents: num(t.totalCents ?? t.total_cents),
+    };
+  }
+  return {
+    timestamp: str(raw, "timestamp"),
+    model: str(raw, "model"),
+    kind: str(raw, "kind", "kindLabel", "kind_label"),
+    maxMode: bool(raw.maxMode ?? raw.max_mode),
+    requestsCosts: num(raw.requestsCosts ?? raw.requests_costs),
+    isTokenBasedCall: bool(raw.isTokenBasedCall ?? raw.is_token_based_call),
+    tokenUsage,
+    userEmail: str(raw, "userEmail", "user_email", "email"),
+    isChargeable: Boolean(raw.isChargeable ?? raw.is_chargeable),
+    isHeadless: bool(raw.isHeadless ?? raw.is_headless),
+  };
+}
+
 export class CursorClient {
   private apiKey: string;
   private baseUrl: string;
@@ -224,7 +269,7 @@ export class CursorClient {
     page?: number;
     pageSize?: number;
   }): Promise<FilteredUsageEventsResponse> {
-    return this.request<FilteredUsageEventsResponse>("/teams/filtered-usage-events", {
+    const data = await this.request<FilteredUsageEventsResponse>("/teams/filtered-usage-events", {
       method: "POST",
       body: {
         email: options.email,
@@ -234,6 +279,14 @@ export class CursorClient {
         pageSize: options.pageSize ?? 500,
       },
     });
+    const usageEvents = (data.usageEvents ?? []).map((row) =>
+      normalizeFilteredUsageEvent(
+        row && typeof row === "object" && !Array.isArray(row)
+          ? (row as unknown as Record<string, unknown>)
+          : {},
+      ),
+    );
+    return { ...data, usageEvents };
   }
 
   async getAICodeCommits(