failproofai 0.0.11-beta.9 → 0.0.11

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

@@ -249,17 +249,20 @@ export interface InviteSendResult {
 /**
  * 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.
+ * so the recipient sees who invited them. `score` (the sender's audit score,
+ * 0–100) is forwarded so the invite body can show "mine came out at N/100";
+ * omit it and the api-server renders score-free copy.
  *
  * Contract is handed over to the platform team separately.
  */
 export async function sendInvites(
   accessToken: string,
   to: string[],
+  score?: number,
 ): Promise<InviteSendResult> {
   return postJson<InviteSendResult>(
     "/v0/invite",
-    { to },
+    score === undefined ? { to } : { to, score },
     { accessToken },
   );
 }

package/lib/client-telemetry.ts

@@ -34,6 +34,10 @@ export function captureClientEvent(
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: payload,
+    // keepalive lets the request outlive a page navigation/unload — without it,
+    // events fired right before the page goes away (client_error / unhandled_*
+    // from an error boundary, or a share click that opens a new tab) are dropped.
+    keepalive: true,
     signal: AbortSignal.timeout(5000),
   }).catch(() => {});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "0.0.11-beta.9",
+  "version": "0.0.11",
   "description": "The easiest way to manage policies that keep your AI agents reliable, on-task, and running autonomously — for Claude Code & the Agents SDK",
   "bin": {
     "failproofai": "./dist/cli.mjs"
@@ -38,7 +38,8 @@
     "translate:readme": "bun scripts/translate-docs/cli.ts --readme-only",
     "translate:docs": "bun scripts/translate-docs/cli.ts --docs-only",
     "translate:dry-run": "bun scripts/translate-docs/cli.ts --dry-run",
-    "translate:validate": "bun scripts/translate-docs/cli.ts --validate"
+    "translate:validate": "bun scripts/translate-docs/cli.ts --validate",
+    "validate:mdx": "bun scripts/validate-mdx.ts"
   },
   "keywords": [
     "claude",
@@ -71,13 +72,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.104.2",
+    "@anthropic-ai/sdk": "^0.105.0",
+    "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.1",
     "@tanstack/react-virtual": "^3.14.3",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "25.9.3",
+    "@types/node": "26.0.0",
     "@types/react": "19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.1",

package/scripts/launch.ts

@@ -5,21 +5,23 @@ import { spawn } from "child_process";
 import { realpathSync, existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
 import { parseScriptArgs } from "./parse-script-args";
 import { diagnoseShadow } from "./install-diagnosis.mjs";
+import { makeSkewLogFilter } from "./skew-log-filter";
 import { version } from "../package.json";
 
 export function launch(mode: "dev" | "start"): void {
   const { loggingLevel, disableTelemetry, allowedDevOrigins, remainingArgs } = parseScriptArgs(process.argv.slice(2));
 
   // Plain-text title + a labeled `Version` line that lines up with the
-  // `Star us` / `Docs` / `Slack` lines below (all four labels pad to the
+  // `Star us` / `Docs` / `Discord` lines below (all four labels pad to the
   // same column so the values form a clean right-hand column).
   console.log(`\n  failproof ai\n`);
   console.log(`  📦 Version:      ${version}`);
   console.log(`  ⭐ Star us:      https://github.com/failproofai/failproofai`);
-  console.log(`  📖 Docs:         https://befailproof.ai`);
-  console.log(`  💬 Slack:        https://join.slack.com/t/failproofai/shared_invite/zt-3v63b7k5e-O3NBHmj8X6n9gZSGDx6ggQ\n`);
+  console.log(`  📖 Docs:         https://docs.befailproof.ai/introduction`);
+  console.log(`  💬 Discord:      https://discord.gg/2zjBZP7yQJ\n`);
 
   let cmd: string;
   let cmdArgs: string[];
@@ -79,16 +81,40 @@ export function launch(mode: "dev" | "start"): void {
     cmdArgs = ["--bun", "next", "dev", ...remainingArgs];
   }
 
+  // In `start` (the shipped standalone server) we pipe + filter the child's
+  // output to drop the benign "Failed to find Server Action" deployment-skew
+  // block — a stale browser tab POSTing an old action ID after a rebuild, which
+  // the client recovers from via Next's graceful 404 (see skew-log-filter.ts).
+  // `dev` keeps "inherit" so Next's interactive compile output is untouched.
+  // FORCE_COLOR keeps the piped child's output colored despite the non-TTY pipe.
+  const filterLogs = mode === "start";
+
   const nextProcess = spawn(cmd, cmdArgs, {
-    stdio: "inherit",
+    stdio: filterLogs ? ["inherit", "pipe", "pipe"] : "inherit",
     env: {
       ...process.env,
+      ...(filterLogs ? { FORCE_COLOR: process.env.FORCE_COLOR ?? "1" } : {}),
       ...(loggingLevel ? { FAILPROOFAI_LOG_LEVEL: loggingLevel } : {}),
       ...(disableTelemetry ? { FAILPROOFAI_TELEMETRY_DISABLED: "1" } : {}),
       ...(allowedDevOrigins ? { FAILPROOFAI_ALLOWED_DEV_ORIGINS: allowedDevOrigins.join(",") } : {}),
     },
   });
 
+  if (filterLogs) {
+    // One filter instance per stream — the skew block is multi-line and stateful.
+    for (const [src, dest] of [
+      [nextProcess.stdout, process.stdout],
+      [nextProcess.stderr, process.stderr],
+    ] as const) {
+      if (!src) continue;
+      const filter = makeSkewLogFilter();
+      createInterface({ input: src }).on("line", (line) => {
+        const out = filter(line);
+        if (out !== null) dest.write(out + "\n");
+      });
+    }
+  }
+
   nextProcess.on("error", (error) => {
     console.error("Error starting Next.js:", error);
     process.exit(1);

package/scripts/postinstall.mjs

@@ -27,6 +27,14 @@ if (!existsSync(serverJsPath)) {
     `  The package may not have been built correctly.\n` +
     `  Try reinstalling: npm install -g failproofai@latest\n`
   );
+  // Await so the event lands before process.exit(1) kills the in-flight fetch —
+  // a failed install is exactly the signal we most want and would otherwise lose.
+  await trackInstallEvent("package_install_failed", {
+    reason: "server_js_missing",
+    platform: platform(),
+    arch: arch(),
+    node_version: process.versions.node,
+  }).catch(() => {});
   process.exit(1);
 }
 
@@ -202,7 +210,7 @@ if (previousVersion === null) {
     arch: arch(),
     os_release: release(),
     node_version: process.versions.node,
-    version: currentVersion,
+    // `version` is carried automatically as `failproofai_version` — no explicit dup.
   }).catch(() => {});
 } else {
   // Same version is a reinstall — still worth tracking; users hitting `npm install -g`
@@ -227,6 +235,7 @@ trackInstallEvent("package_installed", {
   platform: platform(),
   arch: arch(),
   os_release: release(),
+  node_version: process.versions.node,
   hostname_hash: hashToId(hostname()),
   hooks_configured: hooksResult.configured,
   hooks_registered: hooksResult.registered,

package/scripts/skew-log-filter.ts

@@ -0,0 +1,46 @@
+/**
+ * Filters the benign Next.js "Failed to find Server Action" deployment-skew
+ * block out of the standalone server's forwarded output.
+ *
+ * Why this exists: the dashboard ships as a per-version Next standalone build,
+ * and Server Action IDs are hashed at build time. A browser tab left open
+ * across a rebuild/upgrade keeps POSTing a stale action ID the running build no
+ * longer has, so Next throws + logs (server-side, to stderr) a 3-line block:
+ *
+ *     Error: Failed to find Server Action "<hash>". This request might be from an older or newer deployment.
+ *     Read more: https://nextjs.org/docs/messages/failed-to-find-server-action
+ *         at ignore-listed frames
+ *
+ * The client receives a graceful 404 (`x-nextjs-action-not-found: 1`) and
+ * recovers on its own, so the server-side log is pure noise. `launch.ts` pipes
+ * the spawned server's stdout/stderr through this filter (one instance per
+ * stream) to drop that block while passing everything else through verbatim.
+ *
+ * Stateful by design: the block spans multiple lines, so each stream needs its
+ * own filter instance. Call the returned function with each line; it returns
+ * the line to emit, or `null` to drop it.
+ */
+export function makeSkewLogFilter(): (line: string) => string | null {
+  let inSkewBlock = false;
+  return (line: string): string | null => {
+    if (line.includes("Failed to find Server Action")) {
+      inSkewBlock = true;
+      return null;
+    }
+    if (inSkewBlock) {
+      // Continuation lines of the same error block — drop them too.
+      const trimmed = line.trimStart();
+      if (
+        trimmed.startsWith("Read more:") ||
+        line.includes("failed-to-find-server-action") ||
+        line.includes("ignore-listed frames") ||
+        /^\s+at\s/.test(line)
+      ) {
+        return null;
+      }
+      // First line that isn't part of the block — stop dropping and emit it.
+      inSkewBlock = false;
+    }
+    return line;
+  };
+}

package/scripts/validate-mdx.ts

@@ -0,0 +1,139 @@
+/**
+ * Validate that every docs MDX page parses with the same MDX engine Mintlify
+ * runs at deploy time.
+ *
+ * Why this exists: `mintlify validate` (the existing `docs` CI job) only checks
+ * `docs.json` structure and nav-link resolution — it does NOT parse page
+ * content. A page that is structurally referenced but contains an MDX syntax
+ * error (e.g. a `<slug>` that escaped its surrounding backticks because a
+ * translation dropped a closing `` ` ``) passes `mintlify validate` but fails
+ * the Mintlify deploy with:
+ *
+ *   Failed to parse page content at path tr/cli/audit.mdx:
+ *   Expected a closing tag for `<slug>` (61:127-61:133) before the end of `paragraph`
+ *
+ * That deploy runs post-merge, so the failure only surfaces on `main`. The
+ * auto-translation workflow regenerates these pages with an LLM, so this class
+ * of breakage recurs (see the `sanitizeJsxAttributes` / `stripStrayTrailingFence`
+ * heuristics in scripts/translate-docs/mdx-translator.ts — best-effort fixers
+ * that can't catch every case). This script is the deterministic safety net:
+ * run it on every PR so an unparseable page fails CI before it reaches `main`.
+ *
+ * The error string above is emitted by `@mdx-js/mdx`'s micromark MDX layer,
+ * which is the same engine Mintlify uses, so compiling here reproduces the
+ * deploy-time parse faithfully.
+ */
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compile } from "@mdx-js/mdx";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DOCS_DIR = join(__dirname, "..", "docs");
+
+export interface MdxParseError {
+  message: string;
+  line?: number;
+  column?: number;
+}
+
+/**
+ * Replace a leading YAML frontmatter block (`--- … ---`) with blank lines.
+ *
+ * Mintlify parses frontmatter as YAML, not MDX, so it never causes an MDX parse
+ * error. We blank it rather than delete it so the remaining content keeps its
+ * original line numbers — error positions then match the real file.
+ */
+export function stripFrontmatter(source: string): string {
+  const match = /^---\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n?/.exec(source);
+  if (!match) return source;
+  // Keep newlines, drop every other character, so line numbers stay aligned.
+  const blanked = match[0].replace(/[^\n]/g, "");
+  return blanked + source.slice(match[0].length);
+}
+
+/**
+ * Compile one MDX source string with the deploy-time parser. Returns `null`
+ * when it parses cleanly, or the parse error (with position) otherwise.
+ */
+export async function findMdxParseError(
+  source: string,
+): Promise<MdxParseError | null> {
+  try {
+    await compile(stripFrontmatter(source));
+    return null;
+  } catch (err) {
+    const e = err as {
+      reason?: string;
+      message?: string;
+      line?: number;
+      column?: number;
+      place?: { start?: { line?: number; column?: number } };
+    };
+    return {
+      message: e.reason ?? e.message ?? String(err),
+      line: e.line ?? e.place?.start?.line,
+      column: e.column ?? e.place?.start?.column,
+    };
+  }
+}
+
+/**
+ * Percent-encode a value for a GitHub Actions workflow command. Without this a
+ * multi-line MDX error message would be truncated at its first newline (and a
+ * literal `%` could mis-parse) when emitted as an `::error::` annotation.
+ * https://docs.github.com/actions/reference/workflow-commands-for-github-actions
+ */
+export function encodeAnnotation(value: string): string {
+  return value
+    .replace(/%/g, "%25")
+    .replace(/\r/g, "%0D")
+    .replace(/\n/g, "%0A");
+}
+
+function collectMdxFiles(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) out.push(...collectMdxFiles(full));
+    else if (entry.endsWith(".mdx")) out.push(full);
+  }
+  return out;
+}
+
+async function main(): Promise<void> {
+  const files = collectMdxFiles(DOCS_DIR).sort();
+  const failures: Array<{ file: string; error: MdxParseError }> = [];
+
+  for (const file of files) {
+    const error = await findMdxParseError(readFileSync(file, "utf-8"));
+    if (error) failures.push({ file: relative(process.cwd(), file), error });
+  }
+
+  if (failures.length === 0) {
+    console.log(`✓ ${files.length} MDX page(s) parsed cleanly`);
+    return;
+  }
+
+  console.error(
+    `✗ ${failures.length} of ${files.length} MDX page(s) failed to parse:\n`,
+  );
+  for (const { file, error } of failures) {
+    const pos = error.line
+      ? `:${error.line}${error.column ? `:${error.column}` : ""}`
+      : "";
+    console.error(`  ${file}${pos}\n    ${error.message}\n`);
+    // GitHub Actions inline annotation.
+    const loc =
+      (error.line ? `,line=${error.line}` : "") +
+      (error.column ? `,col=${error.column}` : "");
+    console.log(
+      `::error file=${encodeAnnotation(file)}${loc}::MDX parse error: ${encodeAnnotation(error.message)}`,
+    );
+  }
+  process.exitCode = 1;
+}
+
+if (import.meta.main) {
+  void main();
+}