failproofai 1.0.0-beta.0 → 1.0.0-beta.10

package/scripts/repro-npm-install.sh

@@ -0,0 +1,155 @@
+#!/usr/bin/env bash
+# ─────────────────────────────────────────────────────────────────────────────
+# Reproduce a REAL user install, in the shape that actually breaks.
+#
+#   sudo npm i -g failproofai      (global prefix owned by root)
+#   then run the CLI as a NORMAL user
+#
+# That split is the whole point. A single-user laptop where npm's prefix is
+# owned by the person running the hooks hides an entire class of bug — it is
+# how the root-owned policy-shim fail-open shipped: every hook run by a non-root
+# user hit EACCES, the policy never loaded, and the hook exited 0 ALLOWING the
+# call, while builtins kept firing so the machine looked protected.
+#
+# systemd is real here (jrei/systemd-ubuntu), so `failproofai config` installs
+# and starts the actual service rather than skipping that half.
+#
+# Usage:
+#   scripts/repro-npm-install.sh              # build, pack, drop into a shell
+#   scripts/repro-npm-install.sh --published  # install the last RELEASE instead
+# ─────────────────────────────────────────────────────────────────────────────
+set -uo pipefail
+
+REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO"
+
+IMAGE=jrei/systemd-ubuntu:24.04
+NAME=fpai-repro
+USER_IN_BOX=dev
+PUBLISHED=0
+[ "${1:-}" = "--published" ] && PUBLISHED=1
+
+VERSION=$(node -p "require('$REPO/package.json').version")
+say() { printf '\n\033[1m── %s\033[0m\n' "$1"; }
+
+# ── 1. Build what a tarball would carry ──────────────────────────────────────
+if [ "$PUBLISHED" -eq 0 ]; then
+  say "Building dist + daemon"
+  [ -f dist/cli.mjs ] || bun run build
+  [ -f target/release/failproofaid ] || cargo build --release --bin failproofaid
+
+  # `dist/cli.mjs` INLINES the version at build time. `npm pack --ignore-scripts`
+  # skips the `prepare` script that would rebuild it, so bumping package.json
+  # without rebuilding packs a bundle that reports the OLD version — and you
+  # spend an afternoon testing code you did not write. A real publish never hits
+  # this (publish.yml builds, and `prepare` runs on a normal pack); this is a
+  # trap of the fast path only, which is exactly why it is checked here.
+  if ! grep -q "$VERSION" dist/cli.mjs 2>/dev/null; then
+    say "dist is stale (built for $(grep -o '[0-9]\+\.[0-9]\+\.[0-9]\+-beta\.[0-9]\+' dist/cli.mjs | head -1)) — rebuilding"
+    bun run build
+  fi
+
+  say "Packing $VERSION"
+  rm -f failproofai-*.tgz
+  npm pack --ignore-scripts >/dev/null 2>&1
+  TARBALL="$REPO/failproofai-$VERSION.tgz"
+  [ -f "$TARBALL" ] || { echo "pack failed"; exit 1; }
+  ls -la "$TARBALL" | awk '{printf "  %s bytes  %s\n", $5, $9}'
+
+  # Belt and braces: assert what is actually IN the tarball, not what we meant
+  # to put there.
+  PACKED=$(tar -xzOf "$TARBALL" package/dist/cli.mjs 2>/dev/null \
+             | grep -o '[0-9]\+\.[0-9]\+\.[0-9]\+-beta\.[0-9]\+' | head -1)
+  if [ "$PACKED" != "$VERSION" ]; then
+    echo "  REFUSING: tarball reports '$PACKED' but package.json says '$VERSION'"
+    exit 1
+  fi
+  echo "  bundled version verified: $PACKED"
+fi
+
+# ── 2. A container with a real init ──────────────────────────────────────────
+say "Starting $IMAGE (real systemd)"
+docker rm -f "$NAME" >/dev/null 2>&1
+# --cgroupns=host + the two tmpfs mounts are REQUIRED on a cgroup v2 host
+# (anything modern). Without them systemd cannot set up its own hierarchy and
+# the container exits 255 immediately, with an empty `docker logs` — which is
+# a genuinely awful thing to debug, hence the comment.
+docker run -d --name "$NAME" --privileged --cgroupns=host \
+  --network=host \
+  -v /sys/fs/cgroup:/sys/fs/cgroup:rw --tmpfs /run --tmpfs /run/lock \
+  ${TARBALL:+-v "$TARBALL":/pkg.tgz:ro} \
+  -v "$REPO/target/release/failproofaid":/opt/failproofaid:ro \
+  "$IMAGE" >/dev/null
+# Wait for systemd to finish booting, or `systemctl` answers nothing useful.
+until docker exec "$NAME" systemctl is-system-running 2>/dev/null | grep -qE 'running|degraded'; do
+  if ! docker ps --filter "name=$NAME" --format '{{.Names}}' | grep -q "$NAME"; then
+    echo "  container died during boot — cgroup v2 flags wrong for this host?"
+    docker logs "$NAME" 2>&1 | tail -5
+    exit 1
+  fi
+  sleep 1
+done
+echo "  systemd: $(docker exec "$NAME" systemctl is-system-running 2>/dev/null)"
+
+# ── 3. Node, and a NON-ROOT user to run as ───────────────────────────────────
+say "Installing Node + creating an unprivileged user"
+docker exec "$NAME" bash -lc '
+  apt-get update -qq >/dev/null 2>&1
+  apt-get install -y -qq curl ca-certificates sudo >/dev/null 2>&1
+  curl -fsSL https://deb.nodesource.com/setup_22.x -o /tmp/n.sh 2>/dev/null && bash /tmp/n.sh >/dev/null 2>&1
+  apt-get install -y -qq nodejs >/dev/null 2>&1
+  node --version
+' 2>&1 | sed 's/^/  node /'
+
+docker exec "$NAME" bash -lc "
+  id $USER_IN_BOX >/dev/null 2>&1 || useradd -m -s /bin/bash $USER_IN_BOX
+  # Passwordless sudo: the daemon install needs root, and we are testing the
+  # INSTALL, not whether a human can type a password.
+  echo '$USER_IN_BOX ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/$USER_IN_BOX
+  chmod 440 /etc/sudoers.d/$USER_IN_BOX
+"
+
+# ── 4. Install globally AS ROOT — the shape that exposes ownership bugs ──────
+say "npm install -g (as root)"
+if [ "$PUBLISHED" -eq 1 ]; then
+  docker exec "$NAME" bash -lc "npm install -g failproofai@$VERSION 2>&1 | tail -4"
+else
+  docker exec "$NAME" bash -lc "npm install -g /pkg.tgz 2>&1 | tail -4"
+fi
+
+say "Who owns the global install?"
+docker exec "$NAME" bash -lc '
+  P=$(npm root -g)/failproofai
+  stat -c "  %U:%G %a  %n" "$P" 2>/dev/null
+  stat -c "  %U:%G %a  %n" "$P/dist" 2>/dev/null
+'
+
+# ── 5. Hand over, running as the unprivileged user ───────────────────────────
+say "Ready"
+cat <<EOF
+
+  The box is up as container "$NAME". Everything below runs as the
+  UNPRIVILEGED user, against a root-owned global install — the real shape.
+
+  Shell in:
+    docker exec -it -u $USER_IN_BOX $NAME bash -l
+
+  Then, inside:
+    failproofai --version
+    failproofai config          # real systemd service install
+    systemctl status failproofaid@$USER_IN_BOX
+
+  The daemon binary is mounted at /opt/failproofaid. There is no GitHub
+  release for $VERSION, so point the CLI at it rather than letting it try
+  to download one:
+    export FAILPROOFAI_DAEMON_BINARY=/opt/failproofaid
+
+  Fire a hook exactly as an agent CLI would:
+    printf '{"session_id":"s","cwd":"'"\$PWD"'","hook_event_name":"PreToolUse",
+    "tool_name":"Bash","tool_input":{"command":"sudo rm -rf /"}}' \\
+      | failproofai --hook PreToolUse --cli claude
+
+  Tear down:
+    docker rm -f $NAME
+
+EOF

package/scripts/translate-docs/readme-translator.ts

@@ -17,6 +17,158 @@ const ROOT_DIR = join(__dirname, "..", "..");
 const README_PATH = join(ROOT_DIR, "README.md");
 const I18N_DIR = join(ROOT_DIR, "docs", "i18n");
 
+/**
+ * Prefix that walks from `docs/i18n/` back to the repo root. Keep in sync with
+ * I18N_DIR — the disclaimer and language selector already hard-code the same
+ * two levels in their `../../README.md` links.
+ */
+const TO_REPO_ROOT = "../../";
+
+/** Raw-content base for repo files that must resolve off-GitHub too. */
+const RAW_BASE = "https://raw.githubusercontent.com/FailproofAI/failproofai/main/";
+
+const ASSET_RE = /\.(?:png|jpe?g|gif|svg|webp|ico|mp4|webm)$/i;
+
+/**
+ * Re-point the root README's repo-root-relative paths so they still resolve
+ * from `docs/i18n/README.<lang>.md`, two directories deeper.
+ *
+ * The root README lives AT the repo root, so it writes `readme-arch-hq.gif` and
+ * `assets/logos/claude.svg` — correct there. The translator is prompt-forbidden
+ * from touching paths ("Preserve all URLs and paths", translator.ts), and
+ * rightly so, but that means every translated copy inherited those paths
+ * verbatim into a directory two levels down, where they resolve against
+ * `docs/i18n/`. Both consumers 404'd: GitHub asked for
+ * `docs/i18n/assets/logos/claude.svg` and Mintlify (which also serves these
+ * pages, unlisted, at `/i18n/README.<lang>`) asked S3 for `exosphere/i18n/...`.
+ * Every logo and the architecture GIF were broken in all 14 languages.
+ *
+ * The two ref kinds get different treatment because they resolve in different
+ * places:
+ *  - IMAGES become absolute raw.githubusercontent URLs. A `../../` relative
+ *    path would fix GitHub but not Mintlify, whose copy of the page has no
+ *    `assets/` tree above it to walk into — an absolute URL is the only form
+ *    that renders on BOTH surfaces.
+ *  - DOCUMENT links (`./LICENSE`, `./CONTRIBUTING.md`, the translations row's
+ *    `./docs/i18n/README.*.md`) get the `../../` prefix instead. GitHub is the
+ *    only surface where a link to a repo file resolves at all, and a raw URL
+ *    there would serve unrendered plaintext.
+ *
+ * Left alone: absolute URLs, anchors, `mailto:`, protocol-relative `//`,
+ * site-absolute `/`, anything already starting with `../`, and everything
+ * inside a fenced code block (where a path is literal sample text, not a ref).
+ */
+export function rebaseReadmePaths(content: string): string {
+  // Recomputed before each pass. `String.replace` reports offsets into the
+  // string it is scanning, so one map is valid for a whole pass — but a pass
+  // that rewrites a path AHEAD of a fence lengthens the text and shifts that
+  // fence, leaving offsets from the previous string pointing short. The next
+  // pass would then read a literal `<img src=…>` inside a fence as ordinary
+  // markup and rewrite the sample path this guard exists to protect.
+  let fenceRanges = findFenceRanges(content);
+  const insideFence = (offset: number): boolean =>
+    fenceRanges.some(([start, end]) => offset >= start && offset < end);
+
+  const rebase = (path: string): string | null => {
+    if (path === "" || /^[a-z][a-z0-9+.-]*:/i.test(path)) return null; // scheme
+    if (path.startsWith("#") || path.startsWith("/")) return null; // anchor, site-absolute
+    if (path.startsWith("../")) return null; // already rebased
+    const bare = path.replace(/^\.\//, "");
+    if (bare === "" || bare.startsWith("../")) return null;
+    return ASSET_RE.test(bare.split(/[?#]/)[0])
+      ? `${RAW_BASE}${bare}`
+      : `${TO_REPO_ROOT}${bare}`;
+  };
+
+  // Markdown links and images: `](path)` / `](path "title")`.
+  let out = content.replace(
+    /(\]\()([^)\s]+)/g,
+    (match, prefix: string, path: string, offset: number) => {
+      if (insideFence(offset)) return match;
+      const next = rebase(path);
+      return next === null ? match : `${prefix}${next}`;
+    },
+  );
+
+  // HTML/JSX attributes: the README's logo table is a raw <table> of <img>.
+  fenceRanges = findFenceRanges(out);
+  out = out.replace(
+    /((?:src|href)=(["']))(.*?)\2/g,
+    (match, prefix: string, quote: string, path: string, offset: number) => {
+      if (insideFence(offset)) return match;
+      const next = rebase(path);
+      return next === null ? match : `${prefix}${next}${quote}`;
+    },
+  );
+
+  // `srcset` needs its own pass: each logo cell is a <picture> whose dark-mode
+  // <source srcset="assets/logos/*-dark.svg"> sits beside the <img src>. Miss
+  // it and half the table stays broken for dark-theme readers only — the half
+  // least likely to be noticed in review.
+  fenceRanges = findFenceRanges(out);
+  out = out.replace(
+    /(srcset=(["']))(.*?)\2/g,
+    (match, prefix: string, quote: string, value: string, offset: number) => {
+      if (insideFence(offset)) return match;
+      return `${prefix}${rebaseSrcset(value)}${quote}`;
+    },
+  );
+
+  return out;
+
+  /**
+   * Rebase every candidate in a `srcset` value, preserving each one's optional
+   * density/width descriptor (`logo.svg 2x`, `wide.png 800w`) and the original
+   * comma spacing.
+   */
+  function rebaseSrcset(value: string): string {
+    return value
+      .split(",")
+      .map((candidate) => {
+        const [, lead, url, descriptor] =
+          /^(\s*)(\S+)(.*)$/.exec(candidate) ?? [];
+        if (url === undefined) return candidate; // whitespace-only candidate
+        const next = rebase(url);
+        return `${lead}${next ?? url}${descriptor}`;
+      })
+      .join(",");
+  }
+}
+
+/**
+ * Byte ranges covered by fenced code blocks, per CommonMark: a fence opens with
+ * ≥3 backticks or tildes and closes only on a later line using the SAME
+ * character at ≥ the same length.
+ *
+ * Follows the scanner in `mdx-translator.convertHtmlComments`, with one
+ * correction: a CLOSING fence may carry only trailing whitespace, never an info
+ * string. Accepting ```` ```ts ```` as a close would end the block at the first
+ * *nested* opener inside it and leave the real code that follows looking like
+ * prose — whose sample paths this function exists to protect.
+ */
+function findFenceRanges(content: string): Array<[number, number]> {
+  const ranges: Array<[number, number]> = [];
+  const fenceRe = /^[ \t]*(`{3,}|~{3,})([^\n]*)$/gm;
+  let match: RegExpExecArray | null;
+  let open: { char: string; length: number; start: number } | null = null;
+  while ((match = fenceRe.exec(content)) !== null) {
+    const [, marker, rest] = match;
+    if (!open) {
+      open = { char: marker[0], length: marker.length, start: match.index };
+    } else if (
+      marker[0] === open.char &&
+      marker.length >= open.length &&
+      rest.trim() === ""
+    ) {
+      const lineEnd = content.indexOf("\n", fenceRe.lastIndex);
+      ranges.push([open.start, lineEnd === -1 ? content.length : lineEnd]);
+      open = null;
+    }
+  }
+  if (open) ranges.push([open.start, content.length]);
+  return ranges;
+}
+
 function buildLanguageSelector(currentLang: string): string {
   const flags: Record<string, string> = {
     en: "\ud83c\uddfa\ud83c\uddf8",
@@ -117,10 +269,17 @@ export async function translateReadme(
         // Same MDX sanitizers as translateMdxPage — the README emits JSX (the
         // logo table), so strip stray attribute quotes, drop any unmatched
         // trailing code fence (which would swallow the RTL `</div>`), and
-        // convert HTML comments to MDX — then wrap in disclaimer + selector +
-        // RTL div.
-        const cleaned = convertHtmlComments(
-          stripStrayTrailingFence(sanitizeJsxAttributes(raw)),
+        // convert HTML comments to MDX — then re-point the root README's
+        // repo-root-relative paths for this file's depth, and wrap in
+        // disclaimer + selector + RTL div.
+        //
+        // The rebase runs on the model output ONLY, never on the wrapper: the
+        // disclaimer's `../../README.md` and the selector's sibling
+        // `README.<lang>.md` links are already written for `docs/i18n/`.
+        const cleaned = rebaseReadmePaths(
+          convertHtmlComments(
+            stripStrayTrailingFence(sanitizeJsxAttributes(raw)),
+          ),
         );
         return `${disclaimer}\n\n${langSelector}\n\n---\n${rtlOpen}\n${cleaned}\n${rtlClose}`;
       },

package/scripts/validate-mdx.ts

@@ -25,15 +25,22 @@
  * `findPageError`), so this net is a strict superset of `mintlify validate`:
  * it catches both the frontmatter YAML class that fails `mintlify validate`
  * and the body-MDX class that `mintlify validate` lets through to deploy.
+ *
+ * It also covers a third class neither tool sees: image references whose target
+ * does not exist (`findBrokenAssetRefs`). Those are valid MDX and valid YAML —
+ * nothing errors, the reader just gets a broken image — which is how all 14
+ * translated READMEs shipped with every logo and the architecture GIF broken.
+ * See that function for the mechanism.
  */
-import { readdirSync, statSync, readFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
+import { readdirSync, statSync, readFileSync, existsSync } from "node:fs";
+import { dirname, join, relative, resolve, posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import { compile } from "@mdx-js/mdx";
 import YAML from "yaml";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const DOCS_DIR = join(__dirname, "..", "docs");
+const ROOT_DIR = join(__dirname, "..");
+const DOCS_DIR = join(ROOT_DIR, "docs");
 
 export interface MdxParseError {
   message: string;
@@ -178,34 +185,167 @@ export function collectMdxFiles(dir: string): string[] {
   return out;
 }
 
+/** File extensions treated as bundled media rather than a link to a page. */
+const ASSET_RE = /\.(?:png|jpe?g|gif|svg|webp|ico|mp4|webm)$/i;
+
+export interface BrokenAssetRef {
+  /** The reference exactly as written in the page. */
+  ref: string;
+  /** Repo-relative path the reference resolves to, which does not exist. */
+  resolved: string;
+  /** 1-based line the reference appears on. */
+  line: number;
+}
+
+/**
+ * Report every local image reference on a page whose target does not exist on
+ * disk.
+ *
+ * Why this is a separate net from the MDX parse above: a broken image path is
+ * perfectly valid MDX and perfectly valid YAML, so `mintlify validate` and
+ * `findPageError` both pass it — it only surfaces as a missing image in a
+ * reader's browser, which nothing in CI was watching. That is exactly how all
+ * 14 translated READMEs shipped with every logo and the architecture GIF
+ * broken: the translator faithfully copies the root README's repo-root-relative
+ * `assets/logos/*.svg` into `docs/i18n/`, two directories deeper, where they
+ * resolve to nothing (GitHub 404, Mintlify S3 403). The auto-translation
+ * workflow regenerates these pages unattended, so only a deterministic check
+ * keeps that class from coming back.
+ *
+ * Resolution follows the two conventions in this repo:
+ *  - A leading `/` is Mintlify site-absolute → resolve against `docs/`
+ *    (`/agenteye/images/x.png` → `docs/agenteye/images/x.png`).
+ *  - Anything else is relative to the page's own directory, the way GitHub and
+ *    Mintlify both resolve it.
+ *
+ * Skipped: absolute URLs and any other scheme (`https:`, `mailto:`, `data:`),
+ * protocol-relative `//`, bare anchors, and non-asset references — a link to a
+ * `.md`/`.mdx` page or a bare doc slug is nav, already covered by
+ * `mintlify validate`, and would false-positive on extensionless Mintlify
+ * routes.
+ */
+export function findBrokenAssetRefs(
+  file: string,
+  source: string,
+): BrokenAssetRef[] {
+  const pageDir = dirname(file);
+  const out: BrokenAssetRef[] = [];
+  const seen = new Set<string>();
+
+  const lines = source.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const refs = [
+      ...lines[i].matchAll(/\]\(([^)\s]+)/g),
+      ...lines[i].matchAll(/(?:src|href)=["']([^"']+)["']/g),
+    ].map((m) => m[1]);
+
+    // `srcset` carries a comma-separated candidate list, each optionally
+    // followed by a density/width descriptor (`logo.svg 2x`). The README's
+    // logo table pairs every <img src> with a dark-mode <source srcset>, so
+    // extracting only `src` would pass a table half-broken — and only for
+    // dark-theme readers, the half least likely to be caught by eye.
+    for (const m of lines[i].matchAll(/srcset=["']([^"']+)["']/g)) {
+      for (const candidate of m[1].split(",")) {
+        const url = candidate.trim().split(/\s+/)[0];
+        if (url) refs.push(url);
+      }
+    }
+
+    for (const ref of refs) {
+      if (/^[a-z][a-z0-9+.-]*:/i.test(ref)) continue; // https:, mailto:, data:
+      if (ref.startsWith("//") || ref.startsWith("#")) continue;
+      // Strip the query/fragment before testing the extension so a versioned
+      // `x.png?v=2` is still recognised as an asset.
+      const path = ref.split(/[?#]/)[0];
+      if (!ASSET_RE.test(path)) continue;
+
+      const target = path.startsWith("/")
+        ? join(DOCS_DIR, path.slice(1))
+        : resolve(pageDir, path);
+      if (existsSync(target)) continue;
+
+      const key = `${i}:${ref}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({
+        ref,
+        resolved: relative(ROOT_DIR, target).split(/[\\/]/).join(posix.sep),
+        line: i + 1,
+      });
+    }
+  }
+  return out;
+}
+
 async function main(): Promise<void> {
   const files = collectMdxFiles(DOCS_DIR).sort();
-  const failures: Array<{ file: string; error: MdxParseError }> = [];
+  const failures: Array<{
+    file: string;
+    error: MdxParseError;
+    kind: "MDX parse error" | "Broken image";
+  }> = [];
+
+  const collectAssetFailures = (file: string, source: string): void => {
+    for (const broken of findBrokenAssetRefs(file, source)) {
+      failures.push({
+        file: relative(process.cwd(), file),
+        kind: "Broken image",
+        error: {
+          message:
+            `Image \`${broken.ref}\` does not exist — it resolves to ` +
+            `\`${broken.resolved}\`. Paths are relative to the page's own ` +
+            "directory (a leading `/` is relative to `docs/`), so a path " +
+            "copied from a file at a different depth has to be re-pointed.",
+          line: broken.line,
+        },
+      });
+    }
+  };
 
   for (const file of files) {
-    const error = await findPageError(readFileSync(file, "utf-8"));
-    if (error) failures.push({ file: relative(process.cwd(), file), error });
+    const source = readFileSync(file, "utf-8");
+    const error = await findPageError(source);
+    if (error)
+      failures.push({
+        file: relative(process.cwd(), file),
+        error,
+        kind: "MDX parse error",
+      });
+
+    // A page can carry a broken image and still parse, so collect these
+    // independently rather than only when the parse succeeded.
+    collectAssetFailures(file, source);
+  }
+
+  // The root README is not a docs page (it is GitHub-only, and its HTML
+  // comments are illegal MDX, so findPageError would reject it) — but it IS
+  // the source every docs/i18n/README.<lang>.md is translated from. A bad
+  // image path here propagates into 14 files as an absolute raw URL, which
+  // findBrokenAssetRefs deliberately does not follow. Check it at the source.
+  const rootReadme = join(ROOT_DIR, "README.md");
+  if (existsSync(rootReadme)) {
+    collectAssetFailures(rootReadme, readFileSync(rootReadme, "utf-8"));
   }
 
   if (failures.length === 0) {
-    console.log(`✓ ${files.length} MDX page(s) parsed cleanly`);
+    console.log(
+      `✓ ${files.length} MDX page(s) parsed cleanly with no broken images`,
+    );
     return;
   }
 
-  console.error(
-    `✗ ${failures.length} of ${files.length} MDX page(s) failed to parse:\n`,
-  );
-  for (const { file, error } of failures) {
+  console.error(`✗ ${failures.length} problem(s) in ${files.length} page(s):\n`);
+  for (const { file, error, kind } of failures) {
     const pos = error.line
       ? `:${error.line}${error.column ? `:${error.column}` : ""}`
       : "";
-    console.error(`  ${file}${pos}\n    ${error.message}\n`);
+    console.error(`  ${file}${pos}\n    ${kind}: ${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)}`,
+      `::error file=${encodeAnnotation(file)}${loc}::${kind}: ${encodeAnnotation(error.message)}`,
     );
   }
   process.exitCode = 1;