failproofai 0.0.10 → 0.0.11-beta.10

package/.next/standalone/components/reach-developers.tsx

@@ -5,39 +5,51 @@ import React, { useState, useCallback } from "react";
 import { GitBranch, Lightbulb, Bug, MessageSquare, ChevronDown, Star, BookOpen, Hash } from "lucide-react";
 import { Button } from "@/components/ui/button";
 
-const GITHUB_REPO = "https://github.com/exospherehost/failproofai";
+const GITHUB_REPO = "https://github.com/failproofai/failproofai";
 const CONTACT_EMAIL = "failproofai@exosphere.host";
 
 const options = [
   {
     label: "Star us on GitHub",
     icon: Star,
-    href: "https://github.com/exospherehost/failproofai",
+    href: "https://github.com/failproofai/failproofai",
+    color: "#f5c842",
+    bg: "rgba(245,200,66,0.08)",
   },
   {
     label: "Documentation",
     icon: BookOpen,
-    href: "https://befailproof.ai",
+    href: "https://docs.befailproof.ai/",
+    color: "#60a5fa",
+    bg: "rgba(96,165,250,0.08)",
   },
   {
     label: "Join our Slack",
     icon: Hash,
     href: "https://join.slack.com/t/failproofai/shared_invite/zt-3v63b7k5e-O3NBHmj8X6n9gZSGDx6ggQ",
+    color: "#a78bfa",
+    bg: "rgba(167,139,250,0.08)",
   },
   {
     label: "Request a Feature",
     icon: Lightbulb,
     href: `${GITHUB_REPO}/issues/new?labels=enhancement&title=Feature+Request%3A+`,
+    color: "#34d399",
+    bg: "rgba(52,211,153,0.08)",
   },
   {
     label: "Report an Issue",
     icon: Bug,
     href: `${GITHUB_REPO}/issues/new?labels=bug&title=Bug+Report%3A+`,
+    color: "#f87171",
+    bg: "rgba(248,113,113,0.08)",
   },
   {
     label: "Ask a Question",
     icon: MessageSquare,
     href: `${GITHUB_REPO}/discussions/new?category=q-a`,
+    color: "#fb923c",
+    bg: "rgba(251,146,60,0.08)",
   },
 ] as const;
 
@@ -76,35 +88,51 @@ export const ReachDevelopers: React.FC = () => {
       </Button>
 
       {open && (
-        <div className="absolute right-0 mt-2 w-56 rounded-lg border border-border bg-card shadow-lg z-50" role="menu">
-          <div className="px-3 py-2 border-b border-border">
-            <p className="text-xs font-medium text-foreground">Reach Developers</p>
+        <div className="absolute right-0 mt-2 w-60 rounded-lg border border-border bg-card shadow-xl z-50" role="menu"
+          style={{ boxShadow: "0 8px 32px rgba(0,0,0,0.45), 0 0 0 1px rgba(255,255,255,0.04)" }}
+        >
+          <div className="px-3 py-2.5 border-b border-border"
+            style={{ background: "linear-gradient(135deg, rgba(236,72,153,0.12) 0%, rgba(139,92,246,0.08) 100%)" }}
+          >
+            <p className="text-xs font-semibold" style={{ color: "#e879f9", letterSpacing: "0.06em" }}>Reach Developers</p>
             <p className="text-[0.65rem] text-muted-foreground mt-0.5">
               We&apos;d love to hear from you
             </p>
           </div>
           <div className="py-1">
-            {options.map(({ label, icon: Icon, href }) => (
+            {options.map(({ label, icon: Icon, href, color, bg }) => (
               <a
                 key={label}
                 href={href}
                 target="_blank"
                 rel="noopener noreferrer"
                 role="menuitem"
-                className="flex items-center gap-2.5 px-3 py-2 text-xs text-muted-foreground hover:text-foreground hover:bg-muted/50 transition-colors"
+                className="flex items-center gap-2.5 px-3 py-2 text-xs transition-colors"
+                style={{ color: "var(--muted-foreground)" }}
+                onMouseEnter={(e) => {
+                  (e.currentTarget as HTMLAnchorElement).style.background = bg;
+                  (e.currentTarget as HTMLAnchorElement).style.color = color;
+                }}
+                onMouseLeave={(e) => {
+                  (e.currentTarget as HTMLAnchorElement).style.background = "";
+                  (e.currentTarget as HTMLAnchorElement).style.color = "";
+                }}
                 onClick={close}
               >
-                <Icon className="h-3.5 w-3.5 flex-shrink-0" />
+                <Icon className="h-3.5 w-3.5 flex-shrink-0" style={{ color }} />
                 {label}
               </a>
             ))}
           </div>
-          <div className="px-3 py-2 border-t border-border">
+          <div className="px-3 py-2 border-t border-border" style={{ background: "rgba(0,0,0,0.2)" }}>
             <p className="text-[0.65rem] text-muted-foreground">
               or email{" "}
               <a
                 href={`mailto:${CONTACT_EMAIL}`}
-                className="text-primary hover:text-primary/80 transition-colors"
+                className="transition-colors"
+                style={{ color: "#e879f9" }}
+                onMouseEnter={(e) => ((e.currentTarget as HTMLAnchorElement).style.opacity = "0.75")}
+                onMouseLeave={(e) => ((e.currentTarget as HTMLAnchorElement).style.opacity = "1")}
               >
                 {CONTACT_EMAIL}
               </a>

package/.next/standalone/lib/atomic-write.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared atomic-write helper for JSON files we want crash-safe.
+ *
+ * Replaces two near-identical implementations in `lib/auth/auth-store.ts`
+ * and `src/audit/dashboard-cache.ts`. Promoted to a shared module so the
+ * "temp file → chmod → rename → reassert perms" dance is in one place;
+ * the alternative is more drift like the prior PR where dashboard-cache
+ * shipped the non-atomic plain `writeFileSync` path.
+ *
+ * Contract:
+ *  - Concurrent writers can race on the rename, but neither observer
+ *    sees a half-written file.
+ *  - `mode` (default 0o600) is enforced on both the temp and final paths.
+ *  - Parent directory is created with the same `mode` masked to 0o700
+ *    if it doesn't exist.
+ *  - Throws on hard failure; caller decides whether to swallow or surface.
+ */
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+
+export interface WriteJsonOptions {
+  /** Permission mode for the final file (default 0o600). */
+  mode?: number;
+  /** Permission mode used when creating the parent dir (default 0o700). */
+  dirMode?: number;
+}
+
+export function writeJsonAtomically(
+  filePath: string,
+  value: unknown,
+  opts: WriteJsonOptions = {},
+): void {
+  const mode = opts.mode ?? 0o600;
+  const dirMode = opts.dirMode ?? 0o700;
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: dirMode });
+  const tmp = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(value, null, 2), { mode });
+    try {
+      if ((statSync(tmp).mode & 0o077) !== 0) chmodSync(tmp, mode);
+    } catch {
+      // best-effort
+    }
+    renameSync(tmp, filePath);
+    // Re-assert perms on the final path — rename preserves the temp's
+    // mode, but a pre-existing file's inode could have been observed in
+    // the gap.
+    try {
+      if ((statSync(filePath).mode & 0o077) !== 0) chmodSync(filePath, mode);
+    } catch {
+      // best-effort
+    }
+  } catch (err) {
+    try { rmSync(tmp, { force: true }); } catch { /* ignore */ }
+    throw err;
+  }
+}

package/.next/standalone/lib/auth/api-server-client.ts

@@ -0,0 +1,306 @@
+/**
+ * Low-level HTTP client for the FailproofAI api-server's /v0/auth/* endpoints.
+ *
+ * Shared by both the CLI (failproofai auth ...) and the dashboard's Next.js
+ * API route proxies. Has no filesystem access — token persistence lives in
+ * `./auth-store.ts`.
+ *
+ * The base URL is resolved from FAILPROOF_API_URL (preferred) or the legacy
+ * FAILPROOFAI_API_URL, falling back to the hosted api-server. Local-dev
+ * contributors should set FAILPROOF_API_URL=http://localhost:8080 (or
+ * whatever port their local api-server uses) in `.env.local`.
+ */
+
+import { trackEvent } from "../telemetry";
+import { isAbortError } from "../fetch-with-timeout";
+
+export const DEFAULT_API_BASE = "https://api.befailproof.ai";
+
+export function getApiBase(): string {
+  const raw =
+    process.env.FAILPROOF_API_URL ??
+    process.env.FAILPROOFAI_API_URL ??
+    DEFAULT_API_BASE;
+  return raw.replace(/\/+$/, "");
+}
+
+export class AuthApiError extends Error {
+  readonly status: number;
+  readonly code: string;
+  readonly retryAfterSecs?: number;
+  constructor(status: number, code: string, message: string, retryAfterSecs?: number) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfterSecs = retryAfterSecs;
+    this.name = "AuthApiError";
+  }
+}
+
+export interface LoginRequestResponse {
+  status: "code_sent";
+  expires_in: number;
+  resend_available_in: number;
+}
+
+export interface UserView {
+  id: string;
+  email: string;
+}
+
+export interface TokenResponse {
+  token_type: "Bearer";
+  access_token: string;
+  access_expires_in: number;
+  refresh_token: string;
+  refresh_expires_in: number;
+  user: UserView;
+}
+
+export interface RefreshResponse {
+  token_type: "Bearer";
+  access_token: string;
+  access_expires_in: number;
+  refresh_token: string;
+  refresh_expires_in: number;
+}
+
+export interface MeResponse {
+  id: string;
+  email: string;
+  status: string;
+  created_at: string;
+}
+
+interface ServerErrorBody {
+  // The docs describe `{ code, message }`; the live Rust server returns
+  // `{ success: false, code, detail }`. We tolerate either.
+  code?: string;
+  message?: string;
+  detail?: string;
+  retry_after_secs?: number;
+}
+
+async function parseError(res: Response): Promise<AuthApiError> {
+  let body: ServerErrorBody = {};
+  try {
+    body = (await res.json()) as ServerErrorBody;
+  } catch {
+    // body might be empty or non-JSON
+  }
+  const code = body.code ?? `http_${res.status}`;
+  const message = body.message ?? body.detail ?? res.statusText ?? "request failed";
+  let retryAfterSecs = body.retry_after_secs;
+  if (retryAfterSecs === undefined) {
+    const h = res.headers.get("retry-after");
+    if (h) {
+      const n = Number(h);
+      if (Number.isFinite(n)) retryAfterSecs = n;
+    }
+  }
+  // Clamp to a sane range: a misbehaving (or hostile) api-server could
+  // return `-3600` or `1e20` and our UI would render "wait 1e20s" or
+  // backoff loops would fire immediately on negatives. 24h is the longest
+  // wait the dashboard/CLI is willing to surface as a literal duration.
+  if (retryAfterSecs !== undefined) {
+    retryAfterSecs = Math.max(0, Math.min(86400, retryAfterSecs));
+  }
+  return new AuthApiError(res.status, code, message, retryAfterSecs);
+}
+
+/** Hard cap on every auth/reminder HTTP call. Without this, a wedged DNS
+ *  resolver or a hung server keeps the CLI / dashboard route stuck forever. */
+const REQUEST_TIMEOUT_MS = 10_000;
+
+function timeoutSignal(extra?: AbortSignal): AbortSignal {
+  const t = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  if (!extra) return t;
+  // Compose so an externally-cancelled caller still aborts. Prefer the
+  // native `AbortSignal.any` (Node 20.3+, Bun 1.0.27+); fall back to a
+  // hand-rolled controller for older runtimes — without this fallback
+  // an `extra` signal would be silently dropped.
+  const anyFn = (AbortSignal as unknown as { any?: (s: AbortSignal[]) => AbortSignal }).any;
+  if (anyFn) return anyFn([t, extra]);
+  const composed = new AbortController();
+  const onAbort = (s: AbortSignal) => composed.abort(s.reason);
+  if (t.aborted) onAbort(t);
+  else t.addEventListener("abort", () => onAbort(t), { once: true });
+  if (extra.aborted) onAbort(extra);
+  else extra.addEventListener("abort", () => onAbort(extra), { once: true });
+  return composed.signal;
+}
+
+function pathFromUrl(url: string): string {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+
+async function fetchWithTimeout(url: string, init: RequestInit): Promise<Response> {
+  try {
+    return await fetch(url, { ...init, signal: timeoutSignal(init.signal ?? undefined) });
+  } catch (err) {
+    const isTimeout = isAbortError(err);
+    // Low-cardinality "api-server is down" counter. We only attach the
+    // request path (not the full URL) and a coarse kind so it stays a
+    // cheap signal in PostHog. No-ops on the CLI side when telemetry
+    // has not been initialised.
+    trackEvent("api_server_unreachable", {
+      kind: isTimeout ? "timeout" : "network",
+      path: pathFromUrl(url),
+      method: typeof init.method === "string" ? init.method : "GET",
+    });
+    if (isTimeout) {
+      throw new AuthApiError(
+        0,
+        "timeout",
+        `request to ${url} timed out after ${REQUEST_TIMEOUT_MS}ms`,
+      );
+    }
+    throw err;
+  }
+}
+
+async function postJson<T>(path: string, body: unknown, init?: { accessToken?: string }): Promise<T> {
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (init?.accessToken) headers["authorization"] = `Bearer ${init.accessToken}`;
+  const res = await fetchWithTimeout(`${getApiBase()}${path}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  if (res.status === 204) return undefined as T;
+  if (!res.ok) throw await parseError(res);
+  return (await res.json()) as T;
+}
+
+async function getJson<T>(path: string, accessToken: string): Promise<T> {
+  const res = await fetchWithTimeout(`${getApiBase()}${path}`, {
+    method: "GET",
+    headers: { authorization: `Bearer ${accessToken}` },
+  });
+  if (!res.ok) throw await parseError(res);
+  return (await res.json()) as T;
+}
+
+export async function requestLoginCode(email: string): Promise<LoginRequestResponse> {
+  return postJson<LoginRequestResponse>("/v0/auth/login/request", { email });
+}
+
+export async function verifyLoginCode(email: string, code: string): Promise<TokenResponse> {
+  return postJson<TokenResponse>("/v0/auth/login/verify", { email, code });
+}
+
+export async function refreshAccessToken(refreshToken: string): Promise<RefreshResponse> {
+  return postJson<RefreshResponse>("/v0/auth/token/refresh", {
+    refresh_token: refreshToken,
+  });
+}
+
+export async function logoutSession(accessToken: string, refreshToken: string): Promise<void> {
+  await postJson<void>(
+    "/v0/auth/logout",
+    { refresh_token: refreshToken },
+    { accessToken },
+  );
+}
+
+export async function fetchMe(accessToken: string): Promise<MeResponse> {
+  return getJson<MeResponse>("/v0/auth/me", accessToken);
+}
+
+export interface ServerReminder {
+  user_id: string;
+  email: string;
+  fire_at: number; // unix seconds
+  set_at: number;  // unix seconds
+}
+
+export async function scheduleReminder(
+  accessToken: string,
+  body: { in_days?: number; at?: number },
+): Promise<ServerReminder> {
+  const res = await postJson<{ reminder: ServerReminder }>(
+    "/v0/reminders",
+    body,
+    { accessToken },
+  );
+  return res.reminder;
+}
+
+export async function cancelReminder(accessToken: string): Promise<void> {
+  const res = await fetchWithTimeout(`${getApiBase()}/v0/reminders`, {
+    method: "DELETE",
+    headers: { authorization: `Bearer ${accessToken}` },
+  });
+  if (res.status === 204 || res.ok) return;
+  throw await parseError(res);
+}
+
+export interface InviteSendResult {
+  /** Recipients that were dispatched successfully. */
+  sent: string[];
+  /** Recipients that failed (bad address, bounce, rate-limit, etc.). */
+  failed: string[];
+}
+
+/**
+ * Send invite emails to a batch of friends. The api-server pulls the sender's
+ * email from the access-token claims and Cc's them on every outbound message
+ * so the recipient sees who invited them.
+ *
+ * Contract is handed over to the platform team separately.
+ */
+export async function sendInvites(
+  accessToken: string,
+  to: string[],
+): Promise<InviteSendResult> {
+  return postJson<InviteSendResult>(
+    "/v0/invite",
+    { to },
+    { accessToken },
+  );
+}
+
+interface JwtClaims {
+  sub: string;
+  email: string;
+  iss?: string;
+  aud?: string;
+  iat?: number;
+  exp: number;
+  token_type?: string;
+}
+
+/**
+ * Decode the JWT payload without verifying the signature. Safe for client-side
+ * reading (sub, email, exp). Returns null if the token is malformed.
+ *
+ * Strictly validates base64url before decoding: `Buffer.from(s, 'base64url')`
+ * silently truncates on illegal characters (`+`, `/`, whitespace, embedded
+ * NULs) rather than throwing, and the truncated bytes can happen to parse as
+ * JSON with a numeric `exp` field, producing synthetic "valid" claims from a
+ * corrupted token.
+ */
+const BASE64URL_RE = /^[A-Za-z0-9_-]+={0,2}$/;
+
+export function decodeJwt(token: string): JwtClaims | null {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    // Header and payload must both be syntactically valid base64url. Empty
+    // segments are also rejected (Buffer.from("","base64url") would return
+    // an empty buffer that JSON.parse correctly throws on, but rejecting
+    // upfront is cheaper and clearer).
+    if (!BASE64URL_RE.test(parts[0])) return null;
+    if (!BASE64URL_RE.test(parts[1])) return null;
+    const json = Buffer.from(parts[1], "base64url").toString("utf8");
+    const parsed = JSON.parse(json) as JwtClaims;
+    if (typeof parsed.exp !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}