failproofai 0.0.11-beta.2 → 0.0.11-beta.3

package/.next/standalone/app/api/auth/logout/route.ts

@@ -0,0 +1,48 @@
+/**
+ * POST /api/auth/logout
+ *
+ * Reads the locally-stored session, asks the api-server to revoke it, and
+ * deletes ~/.failproofai/auth.json regardless of upstream success — local
+ * intent to log out takes precedence.
+ */
+import { NextResponse } from "next/server";
+import { AuthApiError, logoutSession } from "@/lib/auth/api-server-client";
+import { deleteAuth, readAuth } from "@/lib/auth/auth-store";
+import { initTelemetry, trackEvent } from "@/lib/telemetry";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(): Promise<NextResponse> {
+  await initTelemetry();
+  const existing = readAuth();
+  if (!existing) {
+    trackEvent("audit_user_logged_out", {
+      source: "dashboard",
+      had_session: false,
+      upstream: "noop",
+    });
+    return NextResponse.json({ authenticated: false }, { status: 200 });
+  }
+  let upstream: "revoked" | "skipped" | "failed" = "skipped";
+  let upstreamError: string | null = null;
+  try {
+    await logoutSession(existing.access_token, existing.refresh_token);
+    upstream = "revoked";
+  } catch (err) {
+    if (err instanceof AuthApiError && err.status === 401) {
+      upstream = "revoked"; // token already invalid server-side
+    } else {
+      upstream = "failed";
+      upstreamError = err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200);
+    }
+  }
+  deleteAuth();
+  trackEvent("audit_user_logged_out", {
+    source: "dashboard",
+    had_session: true,
+    upstream,
+    upstream_error: upstreamError,
+    user_id: existing.user.id,
+  });
+  return NextResponse.json({ authenticated: false, upstream }, { status: 200 });
+}

package/.next/standalone/app/api/auth/reminder/route.ts

@@ -0,0 +1,213 @@
+/**
+ * /api/auth/reminder
+ *
+ * GET    — current reminder state (if any, scoped to the signed-in user)
+ * POST   — set or update the next-audit reminder; requires an active session
+ * DELETE — clear the reminder
+ *
+ * Reminder timestamp lives in ~/.failproofai/next-audit.json. The dashboard
+ * AND the CLI can read it later (we just persist intent here; the actual
+ * email send is wired separately when the scheduler is built).
+ */
+import { NextRequest, NextResponse } from "next/server";
+import {
+  deleteReminder,
+  readReminder,
+  whoAmI,
+  writeReminder,
+} from "@/lib/auth/auth-store";
+import {
+  AuthApiError,
+  cancelReminder,
+  scheduleReminder,
+} from "@/lib/auth/api-server-client";
+import { initTelemetry, trackEvent } from "@/lib/telemetry";
+
+export const dynamic = "force-dynamic";
+
+const DEFAULT_OFFSET_DAYS = 7;
+const MAX_OFFSET_DAYS = 365;
+
+export async function GET(): Promise<NextResponse> {
+  const who = await whoAmI();
+  const reminder = readReminder();
+  if (!reminder) {
+    return NextResponse.json({ authenticated: !!who, reminder: null });
+  }
+  // If the reminder belongs to a different user (or no one is signed in),
+  // surface it as null so the UI doesn't show "next audit set for alice"
+  // when bob is the current session.
+  if (!who || who.me.email !== reminder.user_email) {
+    return NextResponse.json({ authenticated: !!who, reminder: null });
+  }
+  return NextResponse.json({
+    authenticated: true,
+    reminder: {
+      next_audit_at: reminder.next_audit_at,
+      user_email: reminder.user_email,
+      set_at: reminder.set_at,
+    },
+  });
+}
+
+interface SetBody {
+  /** Days from now until the reminder fires. Default: 7. */
+  in_days?: unknown;
+  /** Absolute unix-seconds timestamp. Wins over in_days when both are sent. */
+  at?: unknown;
+}
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+  await initTelemetry();
+  const who = await whoAmI();
+  if (!who) {
+    trackEvent("audit_reminder_set", { status: "unauthorized", source: "dashboard" });
+    return NextResponse.json(
+      { code: "unauthorized", message: "Sign in before setting a reminder." },
+      { status: 401 },
+    );
+  }
+  let body: SetBody = {};
+  // Distinguish three cases:
+  //   1. empty body          → defaults (7d from now)
+  //   2. malformed JSON      → 400 Bad Request (don't silently swap to {})
+  //   3. valid JSON, not obj → 400 Bad Request (arrays/primitives are not SetBody)
+  const raw = await req.text();
+  if (raw.trim().length > 0) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      trackEvent("audit_reminder_set", {
+        status: "validation_error",
+        source: "dashboard",
+        reason: "malformed_json",
+        user_id: who.me.id,
+      });
+      return NextResponse.json(
+        { code: "validation_error", message: "Request body is not valid JSON." },
+        { status: 400 },
+      );
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      trackEvent("audit_reminder_set", {
+        status: "validation_error",
+        source: "dashboard",
+        reason: "not_an_object",
+        user_id: who.me.id,
+      });
+      return NextResponse.json(
+        { code: "validation_error", message: "Request body must be a JSON object." },
+        { status: 400 },
+      );
+    }
+    body = parsed as SetBody;
+  }
+  const nowSecs = Math.floor(Date.now() / 1000);
+  const maxAt = nowSecs + MAX_OFFSET_DAYS * 86400;
+  let nextAuditAt: number;
+  if (typeof body.at === "number" && Number.isFinite(body.at)) {
+    nextAuditAt = Math.floor(body.at);
+  } else {
+    const offsetDays =
+      typeof body.in_days === "number" && Number.isFinite(body.in_days)
+        ? Math.max(1, Math.min(MAX_OFFSET_DAYS, Math.floor(body.in_days)))
+        : DEFAULT_OFFSET_DAYS;
+    nextAuditAt = nowSecs + offsetDays * 86400;
+  }
+  if (nextAuditAt <= nowSecs) {
+    trackEvent("audit_reminder_set", {
+      status: "validation_error",
+      source: "dashboard",
+      reason: "in_the_past",
+      user_id: who.me.id,
+    });
+    return NextResponse.json(
+      { code: "validation_error", message: "Reminder must be in the future." },
+      { status: 400 },
+    );
+  }
+  // Upper-bound guard: catches the common foot-gun where a caller passes
+  // `Date.now()` (ms) instead of unix-seconds — would otherwise persist a
+  // year-55000 reminder, render "in 19000000 days", and send nonsense
+  // fire_at to the upstream scheduler.
+  if (nextAuditAt > maxAt) {
+    trackEvent("audit_reminder_set", {
+      status: "validation_error",
+      source: "dashboard",
+      reason: "too_far_in_future",
+      user_id: who.me.id,
+    });
+    return NextResponse.json(
+      {
+        code: "validation_error",
+        message: `Reminder must be within ${MAX_OFFSET_DAYS} days. Did you pass milliseconds instead of seconds?`,
+      },
+      { status: 400 },
+    );
+  }
+  const reminder = {
+    next_audit_at: nextAuditAt,
+    user_email: who.me.email,
+    set_at: nowSecs,
+  };
+  writeReminder(reminder);
+  // Forward to the api-server scheduler so it can deliver via SES. The local
+  // file is the dashboard/CLI source-of-truth; the api-server holds the
+  // delivery slot. We tolerate upstream failure — the local write already
+  // succeeded and the user gets a usable response.
+  let upstream: "scheduled" | "failed" | "skipped" = "skipped";
+  let upstreamError: string | null = null;
+  try {
+    await scheduleReminder(who.auth.access_token, { at: nextAuditAt });
+    upstream = "scheduled";
+  } catch (err) {
+    upstream = "failed";
+    upstreamError =
+      err instanceof AuthApiError
+        ? `${err.code}: ${err.message}`.slice(0, 200)
+        : err instanceof Error
+          ? err.message.slice(0, 200)
+          : String(err).slice(0, 200);
+  }
+  trackEvent("audit_reminder_set", {
+    status: "success",
+    source: "dashboard",
+    user_id: who.me.id,
+    offset_days: Math.round((nextAuditAt - nowSecs) / 86400),
+    upstream,
+    upstream_error: upstreamError,
+  });
+  return NextResponse.json({ authenticated: true, reminder });
+}
+
+export async function DELETE(): Promise<NextResponse> {
+  await initTelemetry();
+  const who = await whoAmI();
+  const existing = readReminder();
+  deleteReminder();
+  let upstream: "cancelled" | "failed" | "skipped" = "skipped";
+  let upstreamError: string | null = null;
+  if (who) {
+    try {
+      await cancelReminder(who.auth.access_token);
+      upstream = "cancelled";
+    } catch (err) {
+      upstream = "failed";
+      upstreamError =
+        err instanceof AuthApiError
+          ? `${err.code}: ${err.message}`.slice(0, 200)
+          : err instanceof Error
+            ? err.message.slice(0, 200)
+            : String(err).slice(0, 200);
+    }
+  }
+  trackEvent("audit_reminder_cleared", {
+    source: "dashboard",
+    had_local_reminder: existing !== null,
+    user_id: who?.me.id ?? null,
+    upstream,
+    upstream_error: upstreamError,
+  });
+  return NextResponse.json({ ok: true });
+}

package/.next/standalone/app/api/auth/status/route.ts

@@ -0,0 +1,42 @@
+/**
+ * GET /api/auth/status
+ *
+ * Returns the currently signed-in identity by reading the local
+ * `~/.failproofai/auth.json` cache. No round-trip to the api-server — the
+ * file is the source of truth, same as the CLI's `failproofai auth whoami`.
+ * This keeps the dashboard UI and the CLI consistent regardless of whether
+ * the api-server is reachable.
+ *
+ * Also returns the user's persisted re-audit reminder (if any). The reminder
+ * lives in ~/.failproofai/next-audit.json and is only surfaced when its
+ * `user_email` matches the active session — so swapping accounts via CLI
+ * does not leak a previous user's reminder into the dashboard.
+ */
+import { NextResponse } from "next/server";
+import { readAuth, readReminder } from "@/lib/auth/auth-store";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(): Promise<NextResponse> {
+  const auth = readAuth();
+  if (!auth) {
+    return NextResponse.json({ authenticated: false, reminder: null }, { status: 200 });
+  }
+  const reminderRaw = readReminder();
+  const reminder =
+    reminderRaw && reminderRaw.user_email === auth.user.email
+      ? {
+          next_audit_at: reminderRaw.next_audit_at,
+          user_email: reminderRaw.user_email,
+          set_at: reminderRaw.set_at,
+        }
+      : null;
+  return NextResponse.json(
+    {
+      authenticated: true,
+      user: { id: auth.user.id, email: auth.user.email },
+      reminder,
+    },
+    { status: 200 },
+  );
+}

package/.next/standalone/app/audit/_components/audit-dashboard.tsx

@@ -0,0 +1,364 @@
+"use client";
+
+/**
+ * Top-level client wrapper for /audit.
+ *
+ * Composes the personality report: classify the agent into one of 8
+ * archetypes, derive a score + tier, render the IdentitySection +
+ * ShowOff + Strengths + Score (with leaderboard) + Findings + Policies
+ * + Return-loop CTA.
+ *
+ * Empty / running states fall back to the existing EmptyState and
+ * RunProgress components.
+ */
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { getAuditResultAction } from "@/app/actions/get-audit-result";
+import type { AuditResult, RunAuditOptions } from "@/src/audit/types";
+import { classifyAgent } from "@/src/audit/archetypes";
+import { COHORT_SIZE, deriveScore, gradeFor, projectedScore, type Grade } from "@/src/audit/scoring";
+import { deriveStrengths } from "@/src/audit/strengths";
+import { deriveFindings } from "@/src/audit/findings";
+import { usePostHog } from "@/contexts/PostHogContext";
+
+import { IdentitySection } from "./identity-section";
+import { ShareDock } from "./share-dock";
+import { StrengthsSection } from "./strengths-section";
+import { ScoreSection } from "./score-section";
+import { FindingsSection } from "./findings-section";
+import { PoliciesSection } from "./policies-section";
+import { ReturnSection } from "./return-section";
+import { ReportFooter } from "./report-footer";
+import { EmptyState } from "./empty-state";
+import { RunProgress } from "./run-progress";
+
+// IMPORTANT: do NOT import BUILTIN_POLICIES or AUDIT_DETECTORS here.
+// Both pull in node:fs and execSync (workflow policies), which Next.js
+// refuses to bundle for the client. The total catalog size is computed
+// server-side in page.tsx and passed in as a plain number prop.
+
+type Initial =
+  | { status: "cached"; cachedAt: string; params: RunAuditOptions; result: AuditResult }
+  | { status: "empty" };
+
+interface Props {
+  initial: Initial;
+  /** ?p=... URL param override for the project name in the leaderboard
+   *  row. Defaults to whichever cwd has the most hits, falling back to
+   *  "your agent". */
+  projectFromUrl?: string;
+  /** Total number of detectors + builtin policies. Computed server-side
+   *  in page.tsx — the modules can't ship to the client. */
+  totalCatalogSize: number;
+}
+
+function inferWindow(params: RunAuditOptions | undefined): string {
+  if (!params?.since) return "all time";
+  return params.since;
+}
+
+function inferProjectName(result: AuditResult, override?: string): string {
+  if (override && override.trim()) return override;
+  // Pick the cwd that appears in the most examples — proxy for "your
+  // most-active project". Falls back to "your agent".
+  const counts = new Map<string, number>();
+  for (const row of result.results) {
+    for (const ex of row.examples) {
+      if (!ex.cwd) continue;
+      counts.set(ex.cwd, (counts.get(ex.cwd) ?? 0) + 1);
+    }
+  }
+  let bestCwd = "";
+  let bestCount = 0;
+  for (const [cwd, n] of counts) {
+    if (n > bestCount) { bestCwd = cwd; bestCount = n; }
+  }
+  if (!bestCwd) return "your agent";
+  const segs = bestCwd.replace(/\/+$/, "").split(/[\\/]/);
+  // Use last two path segments — like "blrnow / api-coder".
+  if (segs.length >= 2) return `${segs[segs.length - 2]} / ${segs[segs.length - 1]}`;
+  return segs[segs.length - 1] ?? "your agent";
+}
+
+export function AuditDashboard({ initial, projectFromUrl, totalCatalogSize }: Props) {
+  const [cache, setCache] = useState<Initial>(initial);
+  const [running, setRunning] = useState(false);
+  const { capture } = usePostHog();
+  const pageViewStateRef = useRef<string | null>(null);
+  const scrollTrackedRef = useRef(false);
+  const transcriptsScanned = cache.status === "cached" ? cache.result.transcripts.scanned : 0;
+  const resultsCount = cache.status === "cached" ? cache.result.results.length : 0;
+
+  const refreshFromCache = useCallback(async () => {
+    const payload = await getAuditResultAction();
+    if (payload.status === "cached") setCache(payload);
+  }, []);
+
+  // Body class for audit-only background + grain texture. Applied once on
+  // mount so the body bg switches from the global #0a0a0a to the audit
+  // #131316 only on this route.
+  useEffect(() => {
+    document.body.classList.add("audit-body");
+    return () => document.body.classList.remove("audit-body");
+  }, []);
+
+  useEffect(() => {
+    const viewState =
+      running
+        ? "running"
+        : cache.status === "empty"
+          ? "empty"
+          : transcriptsScanned === 0
+            ? "zero_sessions"
+            : "report";
+    if (pageViewStateRef.current === viewState) return;
+    pageViewStateRef.current = viewState;
+    capture("audit_page_viewed", {
+      state: viewState,
+      has_cache: cache.status === "cached",
+    });
+  }, [cache.status, capture, running, transcriptsScanned]);
+
+  useEffect(() => {
+    scrollTrackedRef.current = false;
+  }, [cache.status, running, transcriptsScanned]);
+
+  useEffect(() => {
+    if (running || cache.status !== "cached" || transcriptsScanned === 0) return;
+    let raf = 0;
+    const measure = () => {
+      raf = 0;
+      if (scrollTrackedRef.current) return;
+      const maxScroll = document.documentElement.scrollHeight - window.innerHeight;
+      if (maxScroll <= 0) return;
+      const reachedBottom = window.scrollY >= maxScroll - 24;
+      if (!reachedBottom) return;
+      scrollTrackedRef.current = true;
+      capture("audit_page_scrolled_to_end", {
+        results_count: resultsCount,
+        transcripts_scanned: transcriptsScanned,
+      });
+    };
+    // Coalesce scroll events to one rAF — reading scrollHeight forces a
+    // layout reflow, which we don't want firing 60+ times per second.
+    const onScroll = () => {
+      if (raf !== 0) return;
+      raf = requestAnimationFrame(measure);
+    };
+    measure();
+    window.addEventListener("scroll", onScroll, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", onScroll);
+      if (raf !== 0) cancelAnimationFrame(raf);
+    };
+  }, [cache.status, capture, resultsCount, running, transcriptsScanned]);
+
+  /* ---- empty / first-run ----------------------------------------- */
+  if (cache.status === "empty" && !running) {
+    return (
+      <ShellEmpty
+        running={false}
+        onStarted={() => setRunning(true)}
+        onCompleted={async () => { setRunning(false); await refreshFromCache(); }}
+      />
+    );
+  }
+  if (cache.status === "empty" && running) {
+    return (
+      <ShellEmpty
+        running
+        onStarted={() => {}}
+        onCompleted={async () => { setRunning(false); await refreshFromCache(); }}
+      />
+    );
+  }
+
+  // cache.status === "cached"
+  const result = cache.status === "cached" ? cache.result : null;
+  if (!result) return null;
+  const cachedAt = cache.status === "cached" ? cache.cachedAt : null;
+  const params = cache.status === "cached" ? cache.params : undefined;
+
+  /* ---- scanned but zero sessions --------------------------------- */
+  if (result.transcripts.scanned === 0) {
+    return (
+      <ShellEmpty
+        running={running}
+        mode="zero-sessions"
+        onStarted={() => setRunning(true)}
+        onCompleted={async () => { setRunning(false); await refreshFromCache(); }}
+      />
+    );
+  }
+
+  /* ---- in-flight re-run ------------------------------------------ */
+  if (running) {
+    return (
+      <div className="app">
+        <div className="scanline-overlay" />
+        <div className="app-shell">
+          <div className="report">
+            <RunProgress />
+          </div>
+          <ReportFooter cachedAt={cachedAt} />
+        </div>
+      </div>
+    );
+  }
+
+  /* ---- main report ----------------------------------------------- */
+  return (
+    <MainReport
+      result={result}
+      cachedAt={cachedAt}
+      params={params}
+      projectFromUrl={projectFromUrl}
+      totalCatalogSize={totalCatalogSize}
+    />
+  );
+}
+
+interface MainReportProps {
+  result: AuditResult;
+  cachedAt: string | null;
+  params: RunAuditOptions | undefined;
+  projectFromUrl?: string;
+  totalCatalogSize: number;
+}
+
+function MainReport({ result, cachedAt, params, projectFromUrl, totalCatalogSize }: MainReportProps) {
+  const { capture } = usePostHog();
+  const project = useMemo(() => inferProjectName(result, projectFromUrl), [result, projectFromUrl]);
+  // Seed classification with the project name so the behaviour fingerprint
+  // (used for tie-breaks + copy variants) is stable per project.
+  const classification = useMemo(() => classifyAgent(result, project), [result, project]);
+  const score = useMemo(() => deriveScore(result), [result]);
+  const projected = useMemo(() => projectedScore(result, score), [result, score]);
+  const grade = gradeFor(score);
+  const projectedGrade = gradeFor(projected);
+  const strengths = useMemo(() => deriveStrengths(result), [result]);
+  const findings = useMemo(() => deriveFindings(result), [result]);
+  // Renamed from `window` to avoid shadowing the browser global — any
+  // future `window.*` reference added inside MainReport would silently
+  // bind to a string and crash at runtime.
+  const scopeWindow = inferWindow(params);
+
+  // One pass over result.results derives both counts; score-section and
+  // return-section also need `missing` but they take it from us via props
+  // / `result` shape, so deduplicate the scan here.
+  const { detectorsTriggered, missing } = useMemo(() => {
+    let detectorsTriggered = 0;
+    let missing = 0;
+    for (const r of result.results) {
+      if (r.hits > 0) detectorsTriggered++;
+      if (r.source === "builtin" && !r.enabledInConfig && r.hits > 0) missing++;
+    }
+    return { detectorsTriggered, missing };
+  }, [result]);
+
+  // Fire-once dashboard-rendered event so we can compute click-through
+  // rates against the share/download/rerun click events we already track.
+  const dashboardViewedRef = useRef(false);
+  useEffect(() => {
+    if (dashboardViewedRef.current) return;
+    dashboardViewedRef.current = true;
+    capture("audit_dashboard_viewed", {
+      score,
+      grade,
+      archetype: classification.archetype,
+      secondary: classification.secondary ?? null,
+      missing,
+      transcripts_scanned: result.transcripts.scanned,
+      results_count: result.results.length,
+      detectors_triggered: detectorsTriggered,
+    });
+  }, [
+    capture,
+    score,
+    grade,
+    classification.archetype,
+    classification.secondary,
+    missing,
+    result.transcripts.scanned,
+    result.results.length,
+    detectorsTriggered,
+  ]);
+
+  /** Identity hero ref — captured to PNG by the share buttons. */
+  const identityFrameRef = useRef<HTMLDivElement>(null);
+
+  return (
+    <div className="app">
+      <div className="scanline-overlay" />
+      <div className="app-shell">
+        <div className="report">
+          <IdentitySection
+            ref={identityFrameRef}
+            archetypeKey={classification.archetype}
+            secondaryKey={classification.secondary}
+            toolCalls={result.eventsScanned ?? 0}
+            sessions={result.transcripts.scanned}
+            window={scopeWindow}
+            seed={classification.variantSeed}
+          />
+          <StrengthsSection
+            strengths={strengths}
+            totalDetectorsTriggered={detectorsTriggered}
+            totalDetectorsAvailable={totalCatalogSize}
+          />
+          <ScoreSection
+            result={result}
+            score={score}
+            grade={grade}
+            archetypeKey={classification.archetype}
+            project={project}
+          />
+          <ReturnSection result={result} />
+          <FindingsSection findings={findings} />
+          <PoliciesSection result={result} projected={projected} projectedGrade={projectedGrade} />
+        </div>
+        <ReportFooter cachedAt={cachedAt} />
+      </div>
+      <ShareDock
+        frameRef={identityFrameRef}
+        archetypeKey={classification.archetype}
+        seed={classification.variantSeed}
+        score={score}
+        grade={grade}
+        missing={missing}
+      />
+    </div>
+  );
+}
+
+interface ShellEmptyProps {
+  running: boolean;
+  mode?: "no-cache" | "zero-sessions";
+  onStarted: () => void;
+  onCompleted: () => Promise<void> | void;
+}
+
+function ShellEmpty({ running, mode = "no-cache", onStarted, onCompleted }: ShellEmptyProps) {
+  // Use the archetype "optimist" sigil for the empty-state visual so the
+  // page doesn't render with a dead box. EmptyState itself is unchanged
+  // from the previous build.
+  return (
+    <div className="app">
+      <div className="scanline-overlay" />
+      <div className="app-shell">
+        <div className="report">
+          {running ? (
+            <RunProgress />
+          ) : (
+            <EmptyState
+              mode={mode}
+              running={running}
+              onStarted={onStarted}
+              onCompleted={onCompleted}
+            />
+          )}
+        </div>
+        <ReportFooter cachedAt={null} fixed />
+      </div>
+    </div>
+  );
+}