failproofai 1.0.0-beta.4 → 1.0.0-beta.6

package/scripts/launch.ts

@@ -10,22 +10,40 @@ import { parseScriptArgs } from "./parse-script-args";
 import { diagnoseShadow } from "./install-diagnosis.mjs";
 import { makeSkewLogFilter } from "./skew-log-filter";
 import { renderLaunchBanner } from "../src/hooks/tui";
+import { isLoopbackHostname, resolveDashboardHost } from "../lib/dashboard-host";
 import { version } from "../package.json";
 
 export function launch(mode: "dev" | "start"): void {
-  const { loggingLevel, disableTelemetry, allowedDevOrigins, remainingArgs } = parseScriptArgs(process.argv.slice(2));
+  const { loggingLevel, disableTelemetry, allowedDevOrigins, host, remainingArgs } = parseScriptArgs(process.argv.slice(2));
 
   // Branded splash — the same logomark + palette as the `configure` wizard, then
   // a tidy version/links column. Falls back to plain text off a TTY.
   for (const line of renderLaunchBanner(version)) console.log(line);
 
+  // The dashboard has no authentication and can toggle policies and uninstall
+  // hooks from every agent CLI, so it binds loopback unless someone asks
+  // otherwise. It used to bind 0.0.0.0 unconditionally, which handed all of
+  // that to every peer on the network.
+  const bindHost = resolveDashboardHost(host, process.env.FAILPROOFAI_DASHBOARD_HOST);
+  if (!isLoopbackHostname(bindHost)) {
+    console.warn(
+      `\n! Binding the dashboard to ${bindHost}, which is reachable from outside this machine.\n` +
+      `  It has no authentication: anyone who can reach it can read your session\n` +
+      `  transcripts, disable your policies, and uninstall failproofai's hooks.\n`,
+    );
+  }
+  // Read back by proxy.ts, which refuses any request whose Host is not one it
+  // should be answering to — the layer that stops DNS rebinding, which a
+  // loopback bind alone does not.
+  process.env.FAILPROOFAI_DASHBOARD_HOST = bindHost;
+
   let cmd: string;
   let cmdArgs: string[];
   if (mode === "start") {
     const portIdx = remainingArgs.indexOf("--port");
     const port = portIdx >= 0 ? remainingArgs[portIdx + 1] : "8020";
     process.env.PORT = port;
-    process.env.HOSTNAME = "0.0.0.0";
+    process.env.HOSTNAME = bindHost;
     cmd = "node";
     // Resolve the real package root via realpathSync so symlinked npm global binaries
     // don't cause import.meta.url to point at the symlink dir instead of the package dir.
@@ -74,7 +92,11 @@ export function launch(mode: "dev" | "start"): void {
     cmdArgs = [serverJsPath];
   } else {
     cmd = "bunx";
-    cmdArgs = ["--bun", "next", "dev", ...remainingArgs];
+    // `next dev` with no -H listens on every interface too, so dev gets the same
+    // default. Skipped when the caller already passed one through, so an
+    // explicit -H in remainingArgs still wins.
+    const hasHostFlag = remainingArgs.some((a) => a === "-H" || a === "--hostname" || a.startsWith("--hostname="));
+    cmdArgs = ["--bun", "next", "dev", ...(hasHostFlag ? [] : ["-H", bindHost]), ...remainingArgs];
   }
 
   // In `start` (the shipped standalone server) we pipe + filter the child's

package/scripts/parse-script-args.ts

@@ -7,6 +7,13 @@ export interface ParsedScriptArgs {
   loggingLevel: string | undefined;
   disableTelemetry: boolean;
   allowedDevOrigins: string[] | undefined;
+  /**
+   * Interface to bind the dashboard to. Undefined means the safe default
+   * (loopback) — see `resolveDashboardHost` in launch.ts. Only set this to a
+   * non-loopback address deliberately: the dashboard has no authentication and
+   * is a WRITE surface for this machine's security configuration.
+   */
+  host: string | undefined;
   remainingArgs: string[];
 }
 
@@ -32,6 +39,7 @@ export function parseScriptArgs(argv: string[]): ParsedScriptArgs {
   let loggingLevel: string | undefined;
   let disableTelemetry = false;
   let allowedDevOrigins: string[] | undefined;
+  let host: string | undefined;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -71,7 +79,15 @@ export function parseScriptArgs(argv: string[]): ParsedScriptArgs {
       i--;
       continue;
     }
+
+    if (flag === "--host") {
+      const { value, spliceCount } = parseStringFlag(flag, "an address to bind (e.g. 127.0.0.1)", inlineValue, args, i);
+      host = value;
+      args.splice(i, spliceCount);
+      i--;
+      continue;
+    }
   }
 
-  return { loggingLevel, disableTelemetry, allowedDevOrigins, remainingArgs: args };
+  return { loggingLevel, disableTelemetry, allowedDevOrigins, host, remainingArgs: args };
 }

package/scripts/prune-standalone.mjs

@@ -107,6 +107,18 @@ const STANDALONE_ROOT_PRUNE = [
   // RUNNER_TEMP precisely so this cannot happen), and 16 MB of `.gz` shipped
   // inside the CLI tarball once already because nothing pruned them.
   "release-assets", ".daemon-packages",
+  // The Rust workspace. `target/` is the big one: on any machine that has run
+  // `cargo build`, NFT traces it into the standalone output and it is FIFTEEN
+  // GIGABYTES of compiled artifacts — `npm pack` then hangs trying to tar it,
+  // which is how this was found. CI has not hit it because the Rust jobs build
+  // in a separate workspace, so nothing caught it; a contributor who builds the
+  // daemon and then the package hits it every time. The dashboard is a Next
+  // server — it never reads any of this.
+  "target", "crates",
+  // Test/dev trees NFT also over-traces. `integration-suite` is a harness, the
+  // plugin/extension dirs are shipped from the package root by `files`, not
+  // from inside the standalone bundle.
+  "integration-suite", "pi-extension", "openclaw-plugin", "docker-hook-sync",
 ];
 const STANDALONE_ROOT_PRUNE_FILES = [
   // Top-level markdown / licenses / docs
@@ -117,6 +129,14 @@ const STANDALONE_ROOT_PRUNE_FILES = [
   "vitest.config.mts", "vitest.config.e2e.mts",
   // Lockfiles
   "bun.lock", "bun.lockb", "package-lock.json", "yarn.lock",
+  // Rust workspace manifests, siblings of the `target`/`crates` prune above.
+  "Cargo.toml", "Cargo.lock", "rust-toolchain.toml", "osv-scanner.toml",
+  // 11 MB README animation. Traced because it sits in the repo root and is
+  // referenced from README.md; the running dashboard never serves it.
+  "readme-arch-hq.gif",
+  // Incremental typechecker state — regenerated on every build, read by nothing
+  // at runtime, and routinely a few hundred KB.
+  "tsconfig.tsbuildinfo", "next-env.d.ts", "postcss.config.mjs",
 ];
 for (const d of STANDALONE_ROOT_PRUNE) {
   rmSync(join(STANDALONE, d), { recursive: true, force: true });

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;